@antiphony/shared 0.3.0 → 0.5.0

package/dist/cjs/index.cjs

@@ -21,23 +21,15 @@ var __spreadValues = (a, b) => {
 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 resolveAudioUrl(record) {
-  var _a;
-  if ((_a = record.audio) == null ? void 0 : _a.ref) return record.audio.ref;
-  return record.audioUrl;
-}
-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);
@@ -68,136 +60,106 @@ var FirestoreTimestampSchema = zod.z.union([
   }
   return date;
 });
-var UserRecordSchema = 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"),
+var ProcessingStageStatusSchema = zod.z.enum(["pending", "ready", "failed", "skipped"]);
+var PROCESSING_STAGES = ["denoise", "trim", "transcribe", "waveform"];
+var ProcessingStageSchema = zod.z.enum(PROCESSING_STAGES);
+var BYTE_MUTATING_STAGES = ["denoise", "trim"];
+var DERIVED_STAGES = ["transcribe", "waveform"];
+var ProcessingRequestSchema = zod.z.object({
+  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()
 });
-function toProfileViewBasic(profile) {
-  const { id, handle, displayName, avatarUrl, bio, website, links, bluesky, showBlueskyPublicly, stats, badges, isVerified, createdAt } = profile;
-  return {
-    id,
-    handle,
-    displayName,
-    avatarUrl,
-    bio,
-    website,
-    links,
-    bluesky: showBlueskyPublicly ? bluesky : void 0,
-    stats,
-    badges,
-    isVerified,
-    createdAt
-  };
-}
-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()
-});
-var ProfileViewAdminSchema = 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 ProfileViewSchema = ProfileViewAdminSchema;
+var ProcessingViewSchema = ProcessingStageMapSchema;
+function toProcessingView(state) {
+  const view = {};
+  for (const stage of PROCESSING_STAGES) {
+    if (state[stage] !== void 0) view[stage] = state[stage];
+  }
+  return view;
+}
+function resolveAudioVariant(canonical, state) {
+  var _a;
+  if (!state) return canonical;
+  const hasVariant = state.processedBlobCid !== void 0;
+  const peaksAreCurrent = state.waveform === "ready" && state.waveformPeaks !== void 0;
+  return {
+    blobCid: hasVariant ? state.processedBlobCid : canonical.blobCid,
+    durationMs: hasVariant ? (_a = state.processedDurationMs) != null ? _a : canonical.durationMs : canonical.durationMs,
+    waveform: peaksAreCurrent ? state.waveformPeaks : canonical.waveform
+  };
+}
 
 // types/audio.ts
 var StrongRefSchema = zod.z.object({
@@ -210,7 +172,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(),
@@ -233,18 +195,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(),
@@ -262,9 +253,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),
@@ -283,10 +289,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"]
   }
 );
@@ -329,9 +336,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(),
@@ -351,7 +362,16 @@ var CreateAudioPostRequestSchema = zod.z.object({
   /** BCP-47 language tags. */
   langs: zod.z.array(zod.z.string()).max(3).optional(),
   /** Author self-label values (content warnings). */
-  selfLabels: zod.z.array(zod.z.string()).optional()
+  selfLabels: zod.z.array(zod.z.string()).optional(),
+  /**
+   * Opt-in audio processing for this post's audio (denoise / trim /
+   * transcribe / waveform). All default off. Stages the deployment can't
+   * provide come back marked `skipped` on the view rather than failing the
+   * create. A multi-stage request runs denoise → trim → (transcribe,
+   * waveform); request stages individually to override that order. See
+   * `types/processing.ts`.
+   */
+  processing: ProcessingRequestSchema.optional()
 }).refine((d) => !(d.reply && d.title), {
   message: "Replies cannot have a title",
   path: ["title"]
@@ -359,34 +379,11 @@ var CreateAudioPostRequestSchema = zod.z.object({
   message: "Post must have text or an audio embed",
   path: ["text"]
 });
-var UpdateProfileRequestSchema = zod.z.object({
-  handle: zod.z.string().min(3).max(20).regex(/^[a-zA-Z0-9_]+$/).optional(),
-  displayName: zod.z.string().max(50).optional(),
-  bio: zod.z.string().max(160).optional(),
-  avatarUrl: zod.z.string().url().nullable().optional(),
-  usageIntent: zod.z.string().max(200).nullable().optional(),
-  /**
-   * Personal website surfaced on the public profile. Accepts a URL, empty
-   * string, or null from the client; normalizes empty string → null so the
-   * value stored on `UserRecord` (which requires `.url() | null`) round-trips
-   * cleanly through `UserRecordSchema.parse` on subsequent reads.
-   */
-  website: zod.z.union([zod.z.string().url(), zod.z.literal(""), zod.z.null()]).optional().transform((v) => v === "" ? null : v),
-  /** Up to 5 public links (label + URL) shown under the bio. */
-  links: zod.z.array(zod.z.object({
-    label: zod.z.string().min(1).max(40),
-    url: zod.z.string().url()
-  })).max(5).optional(),
-  /** When true, surfaces the linked Bluesky identity on the public profile. */
-  showBlueskyPublicly: zod.z.boolean().optional()
+var PatchAudioPostRequestSchema = zod.z.object({
+  /** Opt-in audio processing to (re)run for this post's audio. Required — a
+   *  PATCH with no processing request is a no-op and rejected as invalid. */
+  processing: ProcessingRequestSchema
 });
-var PublicProfileDtoSchema = ProfileViewBasicSchema.extend({
-  bluesky: zod.z.object({
-    handle: zod.z.string(),
-    did: zod.z.string()
-  }).optional()
-});
-var ActorViewSchema = ProfileViewSelfSchema;
 
 // nsid.ts
 var NSID = {
@@ -394,6 +391,10 @@ var NSID = {
   // See lexicons/dev/antiphony/ + packages/shared/types/audio.ts.
   AudioPost: "dev.antiphony.audio.post",
   AudioTranscript: "dev.antiphony.audio.transcript",
+  // Portable lexicon only — the core never stores actor profiles; the
+  // caller BFF is the sole authority for profile data (see
+  // specs/core-bff-boundary.md, "actor.profile lexicon"). Hence no
+  // COLLECTIONS entry below.
   ActorProfile: "dev.antiphony.actor.profile"
 };
 var EMBED_NSID = {
@@ -401,16 +402,10 @@ var EMBED_NSID = {
   RecordWithAudio: "dev.antiphony.embed.recordWithAudio"
 };
 var COLLECTIONS = {
-  // One post collection + the transcript enrichment namespace + actors.
+  // One post collection + the transcript enrichment namespace.
   [NSID.AudioPost]: "posts",
-  [NSID.AudioTranscript]: "audio_transcripts",
-  [NSID.ActorProfile]: "users"
+  [NSID.AudioTranscript]: "audio_transcripts"
 };
-function nsidForCollection(collection) {
-  const entries = Object.entries(COLLECTIONS);
-  const match = entries.find(([, col]) => col === collection);
-  return match == null ? void 0 : match[0];
-}
 
 // errors/index.ts
 var ServiceError = class extends Error {
@@ -502,43 +497,43 @@ function reportError(err, context) {
 }
 
 exports.ActorProfileRecordSchema = ActorProfileRecordSchema;
-exports.ActorViewSchema = ActorViewSchema;
 exports.AudioEmbedSchema = AudioEmbedSchema;
 exports.AudioEmbedViewSchema = AudioEmbedViewSchema;
 exports.AudioPostRecordSchema = AudioPostRecordSchema;
 exports.AudioPostViewSchema = AudioPostViewSchema;
+exports.BYTE_MUTATING_STAGES = BYTE_MUTATING_STAGES;
 exports.BlobRefSchema = BlobRefSchema;
 exports.COLLECTIONS = COLLECTIONS;
 exports.ConflictError = ConflictError;
 exports.CreateAudioPostRequestSchema = CreateAudioPostRequestSchema;
+exports.DERIVED_STAGES = DERIVED_STAGES;
 exports.EMBED_NSID = EMBED_NSID;
 exports.FirestoreTimestampSchema = FirestoreTimestampSchema;
 exports.ForbiddenError = ForbiddenError;
 exports.NSID = NSID;
 exports.NotFoundError = NotFoundError;
+exports.PROCESSING_STAGES = PROCESSING_STAGES;
+exports.PatchAudioPostRequestSchema = PatchAudioPostRequestSchema;
 exports.PostRecordPublicSchema = PostRecordPublicSchema;
-exports.ProfileViewAdminSchema = ProfileViewAdminSchema;
-exports.ProfileViewBasicSchema = ProfileViewBasicSchema;
-exports.ProfileViewDetailedSchema = ProfileViewDetailedSchema;
-exports.ProfileViewSchema = ProfileViewSchema;
-exports.ProfileViewSelfSchema = ProfileViewSelfSchema;
-exports.PublicProfileDtoSchema = PublicProfileDtoSchema;
+exports.ProcessingRequestSchema = ProcessingRequestSchema;
+exports.ProcessingStageMapSchema = ProcessingStageMapSchema;
+exports.ProcessingStageSchema = ProcessingStageSchema;
+exports.ProcessingStageStatusSchema = ProcessingStageStatusSchema;
+exports.ProcessingStateSchema = ProcessingStateSchema;
+exports.ProcessingViewSchema = ProcessingViewSchema;
 exports.RateLimitError = RateLimitError;
 exports.ReplyRefSchema = ReplyRefSchema;
+exports.ResolvedProcessingSchema = ResolvedProcessingSchema;
 exports.ServiceError = ServiceError;
 exports.StrongRefSchema = StrongRefSchema;
 exports.TimedTranscriptSchema = TimedTranscriptSchema;
 exports.TranscriptEnrichmentRecordSchema = TranscriptEnrichmentRecordSchema;
 exports.TranscriptSegmentSchema = TranscriptSegmentSchema;
 exports.UnauthorizedError = UnauthorizedError;
-exports.UpdateProfileRequestSchema = UpdateProfileRequestSchema;
-exports.UserRecordSchema = UserRecordSchema;
 exports.ValidationError = ValidationError;
 exports.ViewerStateSchema = ViewerStateSchema;
 exports.buildReportedErrorEvent = buildReportedErrorEvent;
-exports.httpsUrl = httpsUrl;
 exports.isFirestoreTimestamp = isFirestoreTimestamp;
-exports.nsidForCollection = nsidForCollection;
 exports.reportError = reportError;
-exports.resolveAudioUrl = resolveAudioUrl;
-exports.toProfileViewBasic = toProfileViewBasic;
+exports.resolveAudioVariant = resolveAudioVariant;
+exports.toProcessingView = toProcessingView;