@antiphony/shared 0.3.0 → 0.5.0

package/dist/cjs/types/audio.cjs

@@ -6,18 +6,15 @@ var zod = require('zod');
 var BlobRefSchema = zod.z.object({
   /** Discriminator for AT Protocol type system */
   $type: zod.z.literal("blob"),
-  /** Content Identifier (CID) or URL pointing to the blob */
-  ref: zod.z.string(),
+  /** IPLD link to the blob bytes: the content CID. */
+  ref: zod.z.object({
+    $link: zod.z.string().min(1)
+  }),
   /** MIME type of the blob (e.g., 'audio/webm') */
   mimeType: zod.z.string(),
   /** Size of the blob in bytes */
-  size: zod.z.number()
+  size: zod.z.number().int().min(0)
 });
-function httpsUrl() {
-  return zod.z.string().trim().url().refine((u) => /^https?:\/\//i.test(u), {
-    message: "URL must use the http or https scheme"
-  });
-}
 var FirestoreTimestampSchema = zod.z.union([
   zod.z.custom((data) => {
     return data && typeof data === "object" && (typeof data.toDate === "function" || "seconds" in data && "nanoseconds" in data);
@@ -48,118 +45,86 @@ var FirestoreTimestampSchema = zod.z.union([
   }
   return date;
 });
+var ProcessingStageStatusSchema = zod.z.enum(["pending", "ready", "failed", "skipped"]);
+var PROCESSING_STAGES = ["denoise", "trim", "transcribe", "waveform"];
+zod.z.enum(PROCESSING_STAGES);
 zod.z.object({
-  /** Unique Firebase UID */
-  id: zod.z.string(),
-  /** Public handle (e.g. @brad). Optional for Lite Users. */
-  handle: zod.z.string().min(3).max(20).regex(/^[a-zA-Z0-9_]+$/).nullable().optional(),
-  /** User stated intent (e.g. "Podcaster", "Listener") */
-  usageIntent: zod.z.string().nullable().optional(),
-  /** Domain for federated handle support. */
-  domain: zod.z.string().default("antiphony.dev"),
+  transcribe: zod.z.boolean().optional(),
+  denoise: zod.z.boolean().optional(),
+  trim: zod.z.boolean().optional(),
+  waveform: zod.z.boolean().optional(),
   /**
-   * Display Name (e.g. "Brad Thorson"). Nullable: Firestore stores `null`
-   * when the user clears this field via the settings form, and the schema
-   * must match storage reality or `UserRecordSchema.parse` (in
-   * `getUserRecordByUid`) will throw.
+   * Whether a completed byte-mutating stage should invalidate and recompute
+   * the derived artifacts that describe the old audio. Defaults to **true**
+   * — a transcript of superseded audio is wrong, not merely stale.
+   *
+   * `false` opts out, for an app that would rather keep the existing
+   * transcript than pay to regenerate it. It does NOT name a stage, so a
+   * request carrying only `reprocess` requests no work.
    */
-  displayName: zod.z.string().max(50).nullable().optional(),
-  /** Short bio/description — nullable for the same reason as displayName. */
-  bio: zod.z.string().max(160).nullable().optional(),
-  /** URL to avatar image — nullable for the same reason as displayName. */
-  avatarUrl: zod.z.string().url().nullable().optional(),
-  /** Optional personal website surfaced on the public profile. */
-  website: httpsUrl().nullable().optional(),
-  /** Up to 5 additional public links (label + URL) shown under the bio. */
-  links: zod.z.array(zod.z.object({
-    label: zod.z.string().min(1).max(40),
-    url: httpsUrl()
-  })).max(5).optional(),
-  /** When true and a Bluesky identity is linked, surfaces it on the public profile. */
-  showBlueskyPublicly: zod.z.boolean().optional(),
-  /** Server timestamp of creation */
-  createdAt: FirestoreTimestampSchema,
-  /** Individual account tier — free or creator_pro */
-  tier: zod.z.enum(["free", "creator_pro"]).default("free"),
-  /** Account status. Deactivated accounts retain data but are excluded from lookups. */
-  status: zod.z.enum(["active", "deactivated"]).default("active"),
-  /** Timestamp when the account was deactivated (soft deleted) */
-  deactivatedAt: FirestoreTimestampSchema.optional()
+  reprocess: zod.z.boolean().optional()
 });
-var ProfileViewBasicSchema = zod.z.object({
-  id: zod.z.string(),
-  handle: zod.z.string().nullable().optional(),
-  // `displayName` and `bio` are `.nullable()` — Firestore stores `null` for
-  // empty values on these fields (see users-dependencies.ts), and Zod's
-  // `.optional()` alone rejects `null`. Consumers already use truthy
-  // checks / `??` / `||`, so widening the type to include `null` is safe.
-  displayName: zod.z.string().nullable().optional(),
-  avatarUrl: zod.z.string().nullable().optional(),
-  bio: zod.z.string().nullable().optional(),
-  /** Personal website link surfaced on the public profile. */
-  website: zod.z.string().nullable().optional(),
-  /** Public links (label + URL) shown under the bio. */
-  links: zod.z.array(zod.z.object({
-    label: zod.z.string(),
-    url: zod.z.string()
-  })).optional(),
-  /**
-   * AT Protocol identity, surfaced on the public profile only when the user
-   * opts in (`UserRecord.showBlueskyPublicly === true`). Projection happens
-   * in the user dependency layer; this schema simply allows the field.
-   */
-  bluesky: zod.z.object({
-    handle: zod.z.string(),
-    did: zod.z.string()
-  }).optional(),
-  stats: zod.z.object({
-    followers: zod.z.number().default(0),
-    following: zod.z.number().default(0),
-    prompts: zod.z.number().default(0)
-  }).optional(),
-  badges: zod.z.array(zod.z.string()).optional(),
-  isVerified: zod.z.boolean().optional(),
-  createdAt: FirestoreTimestampSchema.optional()
+var ProcessingStageMapSchema = zod.z.object({
+  transcribe: ProcessingStageStatusSchema.optional(),
+  denoise: ProcessingStageStatusSchema.optional(),
+  trim: ProcessingStageStatusSchema.optional(),
+  waveform: ProcessingStageStatusSchema.optional()
 });
-var ProfileViewDetailedSchema = ProfileViewBasicSchema.extend({
-  /** AT Protocol Identity link */
-  bluesky: zod.z.object({
-    handle: zod.z.string(),
-    did: zod.z.string()
-  }).optional(),
-  usageIntent: zod.z.string().nullable().optional()
+var ResolvedProcessingSchema = ProcessingStageMapSchema.extend({
+  reprocess: zod.z.boolean().optional()
 });
-var ProfileViewSelfSchema = ProfileViewDetailedSchema.extend({
-  phoneNumber: zod.z.string().nullable().optional(),
-  email: zod.z.string().optional(),
-  lastSeenAt: FirestoreTimestampSchema.optional(),
-  lastActiveAt: FirestoreTimestampSchema.optional(),
-  unreadReplyCount: zod.z.number().default(0),
-  newReplierCount: zod.z.number().default(0),
+var ProcessingStateSchema = ResolvedProcessingSchema.extend({
   /**
-   * Account tier from UserRecord — surfaced on the self profile so the
-   * client can gate paid features. Optional for legacy docs without the
-   * field; consumers should treat missing as `'free'`.
+   * Content CID of the processed audio variant — the composed output of every
+   * byte-mutating stage that has completed. The record's own
+   * `embed.audio.ref.$link` stays the ORIGINAL CID (immutable content
+   * address); only the read-time view swaps playback to this variant.
    */
-  tier: zod.z.enum(["free", "creator_pro"]).optional(),
+  processedBlobCid: zod.z.string().optional(),
   /**
-   * Surfaces the linked Bluesky identity (handle + DID) on the public profile
-   * when true. Persisted on UserRecord; exposed in self/detailed views so the
-   * settings form can render the toggle's current state.
+   * MIME type of the processed variant. Present because providers may
+   * TRANSCODE — the ElevenLabs Voice Isolator returns MP3 regardless of what
+   * it is given — so the variant's type cannot be assumed to match
+   * `embed.audio.mimeType`. Anything reading the variant's bytes must use
+   * this, not the embed's.
    */
-  showBlueskyPublicly: zod.z.boolean().optional(),
-  settings: zod.z.object({
-    notifications: zod.z.boolean().optional(),
-    theme: zod.z.string().optional()
-  }).optional()
-});
-ProfileViewSelfSchema.extend({
-  blockedUsers: zod.z.array(zod.z.string()).optional(),
-  followers: zod.z.array(zod.z.string()).optional(),
-  following: zod.z.array(zod.z.string()).optional(),
-  reportCount: zod.z.number().optional(),
-  isBanned: zod.z.boolean().optional()
+  processedMimeType: zod.z.string().optional(),
+  /**
+   * Duration of the processed variant, when a byte-mutating stage changed it
+   * (i.e. trim). Absent when the variant's duration matches the original.
+   */
+  processedDurationMs: zod.z.number().int().min(0).optional(),
+  /**
+   * Peaks for the processed variant, once the `waveform` stage completes.
+   * Same normalization and bounds as `embed.waveform` (0–100, max 1000), so
+   * a view can never carry a larger payload than the record allows.
+   */
+  waveformPeaks: zod.z.array(zod.z.number().int().min(0).max(100)).max(1e3).optional(),
+  /**
+   * When the current runner's exclusive claim on this post expires.
+   *
+   * Queue delivery is at-least-once, so the same job can arrive twice and
+   * run CONCURRENTLY. `process()` is idempotent under sequential retry — it
+   * acts on `pending` and re-does nothing already settled — but two passes
+   * interleaved is a different failure: both read the same `pending` state,
+   * both bill the provider for the same stage, and both write
+   * `processedBlobCid`, so the surviving variant is whichever finished last
+   * and the other's blob is orphaned.
+   *
+   * A runner claims this field transactionally before doing any work and
+   * clears it when finished; a second runner finding it unexpired declines
+   * and returns. It is an EXPIRY, not a boolean lock, because the holder can
+   * die mid-run (instance recycled, process killed) with no chance to
+   * release — a plain flag would strand the post permanently, where a lapsed
+   * lease lets the next delivery pick it up.
+   *
+   * Internal, like the variant fields above: `toProcessingView` projects
+   * stages only, so this never reaches a client.
+   */
+  leaseUntil: FirestoreTimestampSchema.optional(),
+  updatedAt: FirestoreTimestampSchema
 });
+var ProcessingViewSchema = ProcessingStageMapSchema;
 
 // types/audio.ts
 var StrongRefSchema = zod.z.object({
@@ -172,7 +137,7 @@ var ReplyRefSchema = zod.z.object({
 });
 var AudioEmbedSchema = zod.z.object({
   $type: zod.z.literal("dev.antiphony.embed.audio"),
-  /** The audio bytes as a content-addressed storage ref (CID/path). */
+  /** The audio bytes as a content-addressed blob ref (`ref.$link` = CID). */
   audio: BlobRefSchema,
   /** Duration in MILLISECONDS (platform-wide unit; not seconds). */
   durationMs: zod.z.number().int().min(0).optional(),
@@ -195,18 +160,47 @@ var TimedTranscriptSchema = zod.z.object({
 });
 var AudioEmbedViewSchema = zod.z.object({
   $type: zod.z.literal("dev.antiphony.embed.audio#view"),
+  /**
+   * `url`, `durationMs` and `waveform` are RESOLVED, not copied: once
+   * processing has produced an audio variant they describe that variant
+   * rather than the bytes the client uploaded. They always agree with one
+   * another — a duration and a set of peaks are only meaningful against the
+   * audio `url` actually points at.
+   *
+   * A client that stored `durationMs` at upload time should therefore expect
+   * it to change (trim removes leading/trailing silence), and should render
+   * these three as a set rather than caching them independently. The record's
+   * originals are immutable and unaffected; this is a read-time resolution.
+   */
   url: zod.z.string().url(),
   durationMs: zod.z.number().int().min(0).optional(),
-  // `alt`/`waveform` are copied from the stored embed; keep the same bounds
-  // so a view can never carry a larger payload than the record allows.
+  // `alt` is copied from the stored embed; keep the same bounds so a view can
+  // never carry a larger payload than the record allows.
   alt: zod.z.string().max(1e4).optional(),
   waveform: zod.z.array(zod.z.number().int().min(0).max(100)).max(1e3).optional(),
   /** Lifted from the transcript enrichment record; absent until transcription completes. */
-  transcript: TimedTranscriptSchema.optional()
+  transcript: TimedTranscriptSchema.optional(),
+  /**
+   * Per-stage audio-processing status (denoise / trim / transcribe /
+   * waveform), when the app opted into processing. Absent otherwise. A
+   * `pending` stage means the client should poll (or re-render) for the
+   * result — including a stage that returns to `pending` after having been
+   * `ready`, which is how a recompute surfaces. Once a byte-mutating stage
+   * completes, `url`/`durationMs`/`waveform` above already resolve to the
+   * processed audio variant. See `types/processing.ts`.
+   */
+  processing: ProcessingViewSchema.optional()
 });
 var AudioPostRecordSchema = zod.z.object({
   /** Storage id (rkey/doc id). */
   id: zod.z.string(),
+  /**
+   * Content CID of the canonical lexicon record (CIDv1, dag-cbor, sha2-256
+   * — the AT Protocol record-CID rule). Computed at write time over the
+   * lexicon projection (public fields only, NOT the storage/tenancy fields
+   * below), so StrongRefs built from it are verifiable content addresses.
+   */
+  cid: zod.z.string(),
   // --- Tenancy + facets (storage-indexed; NOT in the lexicon) ---
   /** Origin app that created this record — the multi-tenant isolation key. */
   originAppId: zod.z.string(),
@@ -224,9 +218,24 @@ var AudioPostRecordSchema = zod.z.object({
    * opened the branch. Set on replies (deduped, 1–2 ids); absent on prompts
    * (a prompt's repliers are the app's audience policy, not a fixed pair).
    * Inherited down the branch so reply gating is an O(1) field check, never a
-   * thread walk. See `specs/antiphony-data-model.md` §6 "Reply gating".
+   * thread walk.
    */
   threadParticipants: zod.z.array(zod.z.string()).optional(),
+  /**
+   * Author of this reply's thread ROOT (the prompt) — the reply's recipient,
+   * the person whose "replies to me" feed it lands in. Denormalized at write
+   * time so "replies whose root author is X" is a cheap composite-index query
+   * (see `queryByRootAuthor`). Set on replies (`kind === 'reply'`); absent on
+   * prompts. Storage-layer facet, NOT in the public lexicon or the record CID.
+   */
+  rootAuthorId: zod.z.string().optional(),
+  /**
+   * Async audio-processing state (transcribe / denoise), present iff the app
+   * opted into processing on create. Mutated by the processing worker after
+   * the post is created — storage-layer, NOT in the lexicon or the record
+   * CID. See `types/processing.ts`.
+   */
+  processing: ProcessingStateSchema.optional(),
   // --- Lexicon fields (public contract) ---
   /** User-authored text (bsky-semantic). May be empty for pure-audio posts. NEVER the transcript. */
   text: zod.z.string().max(3e3),
@@ -245,10 +254,11 @@ var AudioPostRecordSchema = zod.z.object({
 }).refine(
   // `kind` is denormalized from `reply` presence at write time; enforce the
   // invariant so an inconsistent record can't be written or read silently.
-  // A reply has `reply` and no `title`; a prompt has neither a `reply`.
-  (r) => r.kind === "reply" ? !!r.reply && r.title === void 0 : !r.reply,
+  // A reply has `reply`, no `title`, and a stamped `rootAuthorId` (its
+  // recipient facet); a prompt has none of those.
+  (r) => r.kind === "reply" ? !!r.reply && r.title === void 0 && r.rootAuthorId !== void 0 : !r.reply && r.rootAuthorId === void 0,
   {
-    message: "kind must match reply presence: 'reply' \u21D2 reply set & no title; 'prompt' \u21D2 no reply",
+    message: "kind must match reply presence: 'reply' \u21D2 reply set, no title, rootAuthorId set; 'prompt' \u21D2 no reply, no rootAuthorId",
     path: ["kind"]
   }
 );
@@ -291,9 +301,13 @@ var PostRecordPublicSchema = zod.z.object({
 var AudioPostViewSchema = zod.z.object({
   /** at:// URI (or internal ref) identifying the post. */
   uri: zod.z.string(),
-  cid: zod.z.string().optional(),
+  /** Content CID of the canonical record (see `AudioPostRecordSchema.cid`). */
+  cid: zod.z.string(),
   kind: zod.z.enum(["prompt", "reply"]),
-  author: ProfileViewBasicSchema,
+  /** The acting actor's app-scoped id — an opaque attribution ref, not a profile. */
+  authorId: zod.z.string(),
+  /** The author's app-asserted AT Protocol DID, when the caller provided one. */
+  authorDid: zod.z.string().optional(),
   record: PostRecordPublicSchema,
   /** Hydrated audio embed (signed URL + lifted transcript). */
   embed: AudioEmbedViewSchema.optional(),