Merge pull request #27 from teal-fm/lexicons

Add lexicons!

apps/aqua/src/auth/client.ts

···
       ? `${url}/client-metadata.json`
       : `http://localhost?redirect_uri=${enc(`${url}/oauth/callback`)}&scope=${enc("atproto transition:generic")}`,
     client_uri: url,
-    redirect_uris: [`${url}/oauth/callback`],
+    redirect_uris: [`${url}/oauth/callback`, `${url}/oauth/callback/app`],
     scope: "atproto transition:generic",
     grant_types: ["authorization_code", "refresh_token"],
     response_types: ["code"],

apps/aqua/src/auth/router.ts

···
 import { setCookie } from "hono/cookie";
 import { env } from "@/lib/env";
 
-export async function callback(c: TealContext) {
+const publicUrl = env.PUBLIC_URL;
+const redirectBase = publicUrl || `http://127.0.0.1:${env.PORT}`;
+
+export function generateState(prefix?: string) {
+  const state = crypto.randomUUID();
+  return `${prefix}${prefix ? ":" : ""}${state}`;
+}
+
+const SPA_PREFIX = "a37d";
+
+// /oauth/login?handle=teal.fm
+export async function login(c: TealContext) {
+  const { handle, spa } = c.req.query();
+  if (!handle) {
+    return Response.json({ error: "Missing handle" });
+  }
+  const url = await atclient.authorize(handle, {
+    scope: "atproto transition:generic",
+    // state.appState in callback
+    state: generateState(spa ? SPA_PREFIX : undefined),
+  });
+  return c.json({ url });
+}
+
+// Redirect to the app's callback URL.
+async function callbackToApp(c: TealContext) {
+  const queries = c.req.query();
+  const params = new URLSearchParams(queries);
+  return c.redirect(`${env.APP_URI}/oauth/callback?${params.toString()}`);
+}
+
+export async function callback(c: TealContext, isSpa: boolean = false) {
   try {
     const honoParams = c.req.query();
     console.log("params", honoParams);
     const params = new URLSearchParams(honoParams);
-    const { session } = await atclient.callback(params);
+
+    const { session, state } = await atclient.callback(params);
+
+    console.log("state", state);
 
     const did = session.did;
 
···
       maxAge: 60 * 60 * 24 * 365,
     });
 
-    if (params.get("spa")) {
+    if (isSpa) {
       return c.json({
         provider: "atproto",
         jwt: did,
···
 
 const app = new Hono<EnvWithCtx>();
 
+app.get("/login", async (c) => login(c));
 app.get("/callback", async (c) => callback(c));
+app.get("/callback/app", async (c) => callback(c, true));
 app.get("/refresh", async (c) => refresh(c));
 
 export const getAuthRouter = () => {

apps/aqua/src/auth/storage.ts

···
       .where(eq(authState.key, key))
       .limit(1)
       .execute();
-    console.log("getting state", key, result);
     if (!result[0]) return;
     return JSON.parse(result[0].state) as NodeSavedState;
   }

apps/aqua/src/lib/env.ts

···
   HOST: host({ devDefault: testOnly("0.0.0.0") }),
   PORT: port({ devDefault: testOnly(3000) }),
   PUBLIC_URL: str({}),
+  APP_URI: str({ devDefault: "fm.teal.amethyst://" }),
   DB_PATH: str({ devDefault: "file:./db.sqlite" }),
   COOKIE_SECRET: str({ devDefault: "secret_cookie! very secret!" }),
 });

package.json

···
     "db:seed": "drizzle-kit seed"
   },
   "devDependencies": {
-    "turbo": "^2.3.0"
+    "turbo": "^2.3.1"
   },
   "engines": {
     "node": ">=21.0.0"

packages/jetstring/src/index.ts

···
 import { status } from "@teal/db/schema";
 import { CommitCreateEvent, Jetstream } from "@skyware/jetstream";
 
+import {
+  Record as XyzStatusphereStatus,
+  isRecord as isStatusphereStatus,
+} from "@teal/lexicons/generated/server/types/xyz/statusphere/status";
+
 class Handler {
   private static instance: Handler;
   private constructor() {}
···
     return Handler.instance;
   }
 
-  handle(msg_type: string, msg: any) {
+  handle(msg_type: string, record: CommitCreateEvent<string & {}>) {
     // Handle message logic here
+    const msg = record.commit.record;
     console.log("Handling" + msg_type + "message:", msg);
-    if (msg_type === "xyz.statusphere.status") {
-      // serialize message as xyz.statusphere.status
-      const st = db.insert(status).values({
-        status: msg.status,
-        uri: msg.uri,
-        authorDid: msg.authorDid,
-      });
+    if (isStatusphereStatus(msg) && msg.$type === "xyz.statusphere.status") {
+      if (record.commit.operation === "create") {
+        // serialize message as xyz.statusphere.status
+        db.insert(status).values({
+          createdAt: new Date().getSeconds().toString(),
+          indexedAt: new Date(record.time_us).getSeconds().toString(),
+          status: msg.status,
+          // the AT path
+          uri: record.commit.rkey,
+          authorDid: record.did,
+        });
+      } else {
+        console.log("unsupported operation:", record.commit.operation);
+      }
+    } else {
+      console.log("Unknown message type:", msg_type);
+      console.log("Message:", record);
     }
   }
 }

packages/lexicons/generated/server/index.ts

···
 export class Server {
   xrpc: XrpcServer
   app: AppNS
+  fm: FmNS
   xyz: XyzNS
 
   constructor(options?: XrpcOptions) {
     this.xrpc = createXrpcServer(schemas, options)
     this.app = new AppNS(this)
+    this.fm = new FmNS(this)
     this.xyz = new XyzNS(this)
   }
 }
···
 export class AppBskyNS {
   _server: Server
   actor: AppBskyActorNS
+  richtext: AppBskyRichtextNS
 
   constructor(server: Server) {
     this._server = server
     this.actor = new AppBskyActorNS(server)
+    this.richtext = new AppBskyRichtextNS(server)
   }
 }
 
 export class AppBskyActorNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}
+
+export class AppBskyRichtextNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}
+
+export class FmNS {
+  _server: Server
+  teal: FmTealNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.teal = new FmTealNS(server)
+  }
+}
+
+export class FmTealNS {
+  _server: Server
+  alpha: FmTealAlphaNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.alpha = new FmTealAlphaNS(server)
+  }
+}
+
+export class FmTealAlphaNS {
+  _server: Server
+  actor: FmTealAlphaActorNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.actor = new FmTealAlphaActorNS(server)
+  }
+}
+
+export class FmTealAlphaActorNS {
   _server: Server
 
   constructor(server: Server) {

packages/lexicons/generated/server/lexicons.ts

···
       },
     },
   },
+  AppBskyRichtextFacet: {
+    lexicon: 1,
+    id: 'app.bsky.richtext.facet',
+    defs: {
+      main: {
+        type: 'object',
+        description: 'Annotation of a sub-string within rich text.',
+        required: ['index', 'features'],
+        properties: {
+          index: {
+            type: 'ref',
+            ref: 'lex:app.bsky.richtext.facet#byteSlice',
+          },
+          features: {
+            type: 'array',
+            items: {
+              type: 'union',
+              refs: [
+                'lex:app.bsky.richtext.facet#mention',
+                'lex:app.bsky.richtext.facet#link',
+                'lex:app.bsky.richtext.facet#tag',
+              ],
+            },
+          },
+        },
+      },
+      mention: {
+        type: 'object',
+        description:
+          "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.",
+        required: ['did'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+        },
+      },
+      link: {
+        type: 'object',
+        description:
+          'Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.',
+        required: ['uri'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'uri',
+          },
+        },
+      },
+      tag: {
+        type: 'object',
+        description:
+          "Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').",
+        required: ['tag'],
+        properties: {
+          tag: {
+            type: 'string',
+            maxLength: 640,
+            maxGraphemes: 64,
+          },
+        },
+      },
+      byteSlice: {
+        type: 'object',
+        description:
+          'Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.',
+        required: ['byteStart', 'byteEnd'],
+        properties: {
+          byteStart: {
+            type: 'integer',
+            minimum: 0,
+          },
+          byteEnd: {
+            type: 'integer',
+            minimum: 0,
+          },
+        },
+      },
+    },
+  },
+  FmTealAlphaActorProfile: {
+    lexicon: 1,
+    id: 'fm.teal.alpha.actor.profile',
+    defs: {
+      main: {
+        type: 'record',
+        description:
+          'This lexicon is in a not officially released state. It is subject to change. | A declaration of a teal.fm account profile.',
+        key: 'literal:self',
+        record: {
+          type: 'object',
+          properties: {
+            displayName: {
+              type: 'string',
+              maxGraphemes: 64,
+              maxLength: 640,
+            },
+            description: {
+              type: 'string',
+              description: 'Free-form profile description text.',
+              maxGraphemes: 256,
+              maxLength: 2560,
+            },
+            descriptionFacets: {
+              type: 'array',
+              description:
+                'Annotations of text in the profile description (mentions, URLs, hashtags, etc).',
+              items: {
+                type: 'ref',
+                ref: 'lex:app.bsky.richtext.facet',
+              },
+            },
+            featuredItem: {
+              type: 'ref',
+              description:
+                "The user's most recent item featured on their profile.",
+              ref: 'lex:fm.teal.alpha.actor.profile#featuredItem',
+            },
+            avatar: {
+              type: 'blob',
+              description:
+                "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            banner: {
+              type: 'blob',
+              description:
+                'Larger horizontal image to display behind profile view.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+      featuredItem: {
+        type: 'object',
+        required: ['mbid', 'type'],
+        properties: {
+          mbid: {
+            type: 'string',
+            description: 'The Musicbrainz ID of the item',
+          },
+          type: {
+            type: 'string',
+            description:
+              'The type of the item. Must be a valid Musicbrainz type, e.g. album, track, recording, etc.',
+          },
+        },
+      },
+    },
+  },
+  FmTealAlphaActorStatus: {
+    lexicon: 1,
+    id: 'fm.teal.alpha.actor.status',
+    defs: {
+      main: {
+        type: 'record',
+        description:
+          'This lexicon is in a not officially released state. It is subject to change. | A declaration of the status of the actor. Only one can be shown at a time. If there are multiple, the latest record should be picked and earlier records should be deleted or tombstoned.',
+        key: 'literal:self',
+        record: {
+          type: 'object',
+          required: ['time', 'item'],
+          properties: {
+            time: {
+              type: 'string',
+              format: 'datetime',
+              description: 'The unix timestamp of when the item was recorded',
+            },
+            item: {
+              type: 'union',
+              refs: ['lex:fm.teal.alpha.play#record'],
+            },
+          },
+        },
+      },
+    },
+  },
+  FmTealAlphaPlay: {
+    lexicon: 1,
+    id: 'fm.teal.alpha.play',
+    description:
+      "This lexicon is in a not officially released state. It is subject to change. | A declaration of a teal.fm play. Plays are submitted as a result of a user listening to a track. Plays should be marked as tracked when a user has listened to the entire track if it's under 2 minutes long, or half of the track's duration up to 4 minutes, whichever is longest.",
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['trackName', 'artistName'],
+          properties: {
+            trackName: {
+              type: 'string',
+              minLength: 1,
+              maxLength: 256,
+              maxGraphemes: 2560,
+              description: 'The name of the track',
+            },
+            trackMbId: {
+              type: 'string',
+              description: 'The Musicbrainz ID of the track',
+            },
+            recordingMbId: {
+              type: 'string',
+              description: 'The Musicbrainz recording ID of the track',
+            },
+            duration: {
+              type: 'integer',
+              description: 'The length of the track in seconds',
+            },
+            artistName: {
+              type: 'string',
+              minLength: 1,
+              maxLength: 256,
+              maxGraphemes: 2560,
+              description: 'The name of the artist',
+            },
+            artistMbIds: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+              description: 'Array of Musicbrainz artist IDs',
+            },
+            releaseName: {
+              type: 'string',
+              maxLength: 256,
+              maxGraphemes: 2560,
+              description: 'The name of the release/album',
+            },
+            releaseMbId: {
+              type: 'string',
+              description: 'The Musicbrainz release ID',
+            },
+            isrc: {
+              type: 'string',
+              description: 'The ISRC code associated with the recording',
+            },
+            originUrl: {
+              type: 'string',
+              description: 'The URL associated with this track',
+            },
+            musicServiceBaseDomain: {
+              type: 'string',
+              description:
+                'The base domain of the music service. e.g. music.apple.com, tidal.com, spotify.com.',
+            },
+            submissionClientAgent: {
+              type: 'string',
+              maxLength: 256,
+              maxGraphemes: 2560,
+              description:
+                'A user-agent style string specifying the user agent. e.g. tealtracker/0.0.1b',
+            },
+            playedTime: {
+              type: 'string',
+              format: 'datetime',
+              description: 'The unix timestamp of when the track was played',
+            },
+          },
+        },
+      },
+    },
+  },
   XyzStatusphereStatus: {
     lexicon: 1,
     id: 'xyz.statusphere.status',
···
 export const lexicons: Lexicons = new Lexicons(schemas)
 export const ids = {
   AppBskyActorProfile: 'app.bsky.actor.profile',
+  AppBskyRichtextFacet: 'app.bsky.richtext.facet',
+  FmTealAlphaActorProfile: 'fm.teal.alpha.actor.profile',
+  FmTealAlphaActorStatus: 'fm.teal.alpha.actor.status',
+  FmTealAlphaPlay: 'fm.teal.alpha.play',
   XyzStatusphereStatus: 'xyz.statusphere.status',
 }

packages/lexicons/generated/server/types/app/bsky/richtext/facet.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+
+/** Annotation of a sub-string within rich text. */
+export interface Main {
+  index: ByteSlice
+  features: (Mention | Link | Tag | { $type: string; [k: string]: unknown })[]
+  [k: string]: unknown
+}
+
+export function isMain(v: unknown): v is Main {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'app.bsky.richtext.facet#main' ||
+      v.$type === 'app.bsky.richtext.facet')
+  )
+}
+
+export function validateMain(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.richtext.facet#main', v)
+}
+
+/** Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID. */
+export interface Mention {
+  did: string
+  [k: string]: unknown
+}
+
+export function isMention(v: unknown): v is Mention {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.richtext.facet#mention'
+  )
+}
+
+export function validateMention(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.richtext.facet#mention', v)
+}
+
+/** Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL. */
+export interface Link {
+  uri: string
+  [k: string]: unknown
+}
+
+export function isLink(v: unknown): v is Link {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.richtext.facet#link'
+  )
+}
+
+export function validateLink(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.richtext.facet#link', v)
+}
+
+/** Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags'). */
+export interface Tag {
+  tag: string
+  [k: string]: unknown
+}
+
+export function isTag(v: unknown): v is Tag {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.richtext.facet#tag'
+  )
+}
+
+export function validateTag(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.richtext.facet#tag', v)
+}
+
+/** Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets. */
+export interface ByteSlice {
+  byteStart: number
+  byteEnd: number
+  [k: string]: unknown
+}
+
+export function isByteSlice(v: unknown): v is ByteSlice {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.richtext.facet#byteSlice'
+  )
+}
+
+export function validateByteSlice(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.richtext.facet#byteSlice', v)
+}

packages/lexicons/generated/server/types/fm/teal/alpha/actor/profile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../../lexicons'
+import { isObj, hasProp } from '../../../../../util'
+import { CID } from 'multiformats/cid'
+import * as AppBskyRichtextFacet from '../../../../app/bsky/richtext/facet'
+
+export interface Record {
+  displayName?: string
+  /** Free-form profile description text. */
+  description?: string
+  /** Annotations of text in the profile description (mentions, URLs, hashtags, etc). */
+  descriptionFacets?: AppBskyRichtextFacet.Main[]
+  featuredItem?: FeaturedItem
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef
+  /** Larger horizontal image to display behind profile view. */
+  banner?: BlobRef
+  createdAt?: string
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'fm.teal.alpha.actor.profile#main' ||
+      v.$type === 'fm.teal.alpha.actor.profile')
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('fm.teal.alpha.actor.profile#main', v)
+}
+
+export interface FeaturedItem {
+  /** The Musicbrainz ID of the item */
+  mbid: string
+  /** The type of the item. Must be a valid Musicbrainz type, e.g. album, track, recording, etc. */
+  type: string
+  [k: string]: unknown
+}
+
+export function isFeaturedItem(v: unknown): v is FeaturedItem {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'fm.teal.alpha.actor.profile#featuredItem'
+  )
+}
+
+export function validateFeaturedItem(v: unknown): ValidationResult {
+  return lexicons.validate('fm.teal.alpha.actor.profile#featuredItem', v)
+}

packages/lexicons/generated/server/types/fm/teal/alpha/actor/status.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../../lexicons'
+import { isObj, hasProp } from '../../../../../util'
+import { CID } from 'multiformats/cid'
+import * as FmTealAlphaPlay from '../play'
+
+export interface Record {
+  /** The unix timestamp of when the item was recorded */
+  time: string
+  item: FmTealAlphaPlay.Record | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'fm.teal.alpha.actor.status#main' ||
+      v.$type === 'fm.teal.alpha.actor.status')
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('fm.teal.alpha.actor.status#main', v)
+}

packages/lexicons/generated/server/types/fm/teal/alpha/play.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+
+export interface Record {
+  /** The name of the track */
+  trackName: string
+  /** The Musicbrainz ID of the track */
+  trackMbId?: string
+  /** The Musicbrainz recording ID of the track */
+  recordingMbId?: string
+  /** The length of the track in seconds */
+  duration?: number
+  /** The name of the artist */
+  artistName: string
+  /** Array of Musicbrainz artist IDs */
+  artistMbIds?: string[]
+  /** The name of the release/album */
+  releaseName?: string
+  /** The Musicbrainz release ID */
+  releaseMbId?: string
+  /** The ISRC code associated with the recording */
+  isrc?: string
+  /** The URL associated with this track */
+  originUrl?: string
+  /** The base domain of the music service. e.g. music.apple.com, tidal.com, spotify.com. */
+  musicServiceBaseDomain?: string
+  /** A user-agent style string specifying the user agent. e.g. tealtracker/0.0.1b */
+  submissionClientAgent?: string
+  /** The unix timestamp of when the track was played */
+  playedTime?: string
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'fm.teal.alpha.play#main' || v.$type === 'fm.teal.alpha.play')
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('fm.teal.alpha.play#main', v)
+}

packages/lexicons/src/app.bsky.richtext.facet.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.richtext.facet",
+  "defs": {
+    "main": {
+      "type": "object",
+      "description": "Annotation of a sub-string within rich text.",
+      "required": ["index", "features"],
+      "properties": {
+        "index": { "type": "ref", "ref": "#byteSlice" },
+        "features": {
+          "type": "array",
+          "items": { "type": "union", "refs": ["#mention", "#link", "#tag"] }
+        }
+      }
+    },
+    "mention": {
+      "type": "object",
+      "description": "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.",
+      "required": ["did"],
+      "properties": {
+        "did": { "type": "string", "format": "did" }
+      }
+    },
+    "link": {
+      "type": "object",
+      "description": "Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.",
+      "required": ["uri"],
+      "properties": {
+        "uri": { "type": "string", "format": "uri" }
+      }
+    },
+    "tag": {
+      "type": "object",
+      "description": "Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').",
+      "required": ["tag"],
+      "properties": {
+        "tag": { "type": "string", "maxLength": 640, "maxGraphemes": 64 }
+      }
+    },
+    "byteSlice": {
+      "type": "object",
+      "description": "Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.",
+      "required": ["byteStart", "byteEnd"],
+      "properties": {
+        "byteStart": { "type": "integer", "minimum": 0 },
+        "byteEnd": { "type": "integer", "minimum": 0 }
+      }
+    }
+  }
+}

packages/lexicons/src/fm.teal.alpha.actor.profile.json

···
+{
+  "lexicon": 1,
+  "id": "fm.teal.alpha.actor.profile",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "This lexicon is in a not officially released state. It is subject to change. | A declaration of a teal.fm account profile.",
+      "key": "literal:self",
+      "record": {
+        "type": "object",
+        "properties": {
+          "displayName": {
+            "type": "string",
+            "maxGraphemes": 64,
+            "maxLength": 640
+          },
+          "description": {
+            "type": "string",
+            "description": "Free-form profile description text.",
+            "maxGraphemes": 256,
+            "maxLength": 2560
+          },
+          "descriptionFacets": {
+            "type": "array",
+            "description": "Annotations of text in the profile description (mentions, URLs, hashtags, etc).",
+            "items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+          },
+          "featuredItem": {
+            "type": "ref",
+            "description": "The user's most recent item featured on their profile.",
+            "ref": "#featuredItem"
+          },
+          "avatar": {
+            "type": "blob",
+            "description": "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+            "accept": ["image/png", "image/jpeg"],
+            "maxSize": 1000000
+          },
+          "banner": {
+            "type": "blob",
+            "description": "Larger horizontal image to display behind profile view.",
+            "accept": ["image/png", "image/jpeg"],
+            "maxSize": 1000000
+          },
+          "createdAt": { "type": "string", "format": "datetime" }
+        }
+      }
+    },
+    "featuredItem": {
+      "type": "object",
+      "required": ["mbid", "type"],
+      "properties": {
+        "mbid": {
+          "type": "string",
+          "description": "The Musicbrainz ID of the item"
+        },
+        "type": {
+          "type": "string",
+          "description": "The type of the item. Must be a valid Musicbrainz type, e.g. album, track, recording, etc."
+        }
+      }
+    }
+  }
+}

packages/lexicons/src/fm.teal.alpha.actor.status.json

···
+{
+  "lexicon": 1,
+  "id": "fm.teal.alpha.actor.status",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "This lexicon is in a not officially released state. It is subject to change. | A declaration of the status of the actor. Only one can be shown at a time. If there are multiple, the latest record should be picked and earlier records should be deleted or tombstoned.",
+      "key": "literal:self",
+      "record": {
+        "type": "object",
+        "required": ["time", "item"],
+        "properties": {
+          "time": {
+            "type": "string",
+            "format": "datetime",
+            "description": "The unix timestamp of when the item was recorded"
+          },
+          "item": { "type": "union", "refs": ["fm.teal.alpha.play#record"] }
+        }
+      }
+    }
+  }
+}

packages/lexicons/src/fm.teal.alpha.play.json

···
+{
+  "lexicon": 1,
+  "id": "fm.teal.alpha.play",
+  "description": "This lexicon is in a not officially released state. It is subject to change. | A declaration of a teal.fm play. Plays are submitted as a result of a user listening to a track. Plays should be marked as tracked when a user has listened to the entire track if it's under 2 minutes long, or half of the track's duration up to 4 minutes, whichever is longest.",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["trackName", "artistName"],
+        "properties": {
+          "trackName": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 256,
+            "maxGraphemes": 2560,
+            "description": "The name of the track"
+          },
+          "trackMbId": {
+            "type": "string",
+
+            "description": "The Musicbrainz ID of the track"
+          },
+          "recordingMbId": {
+            "type": "string",
+            "description": "The Musicbrainz recording ID of the track"
+          },
+          "duration": {
+            "type": "integer",
+            "description": "The length of the track in seconds"
+          },
+          "artistName": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 256,
+            "maxGraphemes": 2560,
+            "description": "The name of the artist"
+          },
+          "artistMbIds": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Array of Musicbrainz artist IDs"
+          },
+          "releaseName": {
+            "type": "string",
+            "maxLength": 256,
+            "maxGraphemes": 2560,
+            "description": "The name of the release/album"
+          },
+          "releaseMbId": {
+            "type": "string",
+            "description": "The Musicbrainz release ID"
+          },
+          "isrc": {
+            "type": "string",
+            "description": "The ISRC code associated with the recording"
+          },
+          "originUrl": {
+            "type": "string",
+            "description": "The URL associated with this track"
+          },
+          "musicServiceBaseDomain": {
+            "type": "string",
+            "description": "The base domain of the music service. e.g. music.apple.com, tidal.com, spotify.com."
+          },
+          "submissionClientAgent": {
+            "type": "string",
+            "maxLength": 256,
+            "maxGraphemes": 2560,
+            "description": "A user-agent style string specifying the user agent. e.g. tealtracker/0.0.1b"
+          },
+          "playedTime": {
+            "type": "string",
+            "format": "datetime",
+            "description": "The unix timestamp of when the track was played"
+          }
+        }
+      }
+    }
+  }
+}