@sixb/core 0.1.16 → 0.1.18

package/src/materializer/projections/replacement-plan.ts

@@ -1,26 +1,22 @@
-import type {
-  EffectiveChangeCounts,
-  EffectiveLinkChange,
-  EffectiveObjectChange,
-  OntologyMaterializationOrigin,
-  OntologyObjectRef,
-  ProjectionSourceRef,
-} from "../../materialization/model"
+import type { EffectiveLinkChange, EffectiveObjectChange } from "../../materialization/model"
 import {
   linkRefKey,
   linkRefSortKey,
   linkScopeSortKey,
   objectRefKey,
   objectRefSortKey,
+  utf8JsonByteLength,
 } from "../../materialization/refs"
 import type {
   MaterializationPlanWorkItem,
-  MaterializationSession,
   MaterializationWorkRecord,
-  OntologyMaterializationStorage,
+  OntologyCommitWrite,
+  OntologyReplacementPlanStorage,
+  PlannedReplacementIdentity,
+  ReplacementPlanRef,
   SourceReplacementLinkState,
   SourceReplacementObjectState,
-  SourceReplacementStatePage,
+  StageReplacementPlanInput,
 } from "../../storage/ontology"
 import type { MaterializerContext } from "../context"
 import {
@@ -28,7 +24,6 @@ import {
   buildObjectMaterializationEventDraft,
 } from "../effective/build-events"
 import { diffEffectiveLink, diffEffectiveObject } from "../effective/diff"
-import { oneStateRequest } from "../effective/load-state"
 import {
   resolveEffectiveLink,
   resolveEffectiveLinkSlotMember,
@@ -37,8 +32,6 @@ import {
   usableLinkSlotOverride,
 } from "../effective/resolve"
 import { validateEffectiveObject } from "../effective/validate"
-import type { MaterializerAttribution } from "../execution/scope"
-import { stageWorkBounded, validateStagedCardinality } from "../execution/work-executor"
 import {
   appendEffectiveLinkWork,
   appendEffectiveObjectWork,
@@ -47,72 +40,84 @@ import {
   planWork,
 } from "../execution/work-records"
 import { throwIfAborted } from "../shared/abort"
-import type { TimedCommitIdentity } from "../shared/identity"
+import { chunkBySize } from "../shared/chunking"
 
 export interface ProjectionReplacementPlanInput {
-  readonly source: ProjectionSourceRef
-  readonly materializationId: string
   readonly projectionKind: "object" | "link"
-  readonly identity: TimedCommitIdentity
-  readonly origin: OntologyMaterializationOrigin
-  readonly correlationId: string
-  readonly attribution: MaterializerAttribution
+  /** The commit the plan carries, timed as the plan was opened. */
+  readonly commit: OntologyCommitWrite
   readonly signal?: AbortSignal
 }
 
+/**
+ * Plans every identity of the candidate's durable plan still to plan, outside any transaction.
+ * Objects come first: a link resolves against the existence its endpoints are planned to have.
+ */
 export async function planProjectionReplacement(
   context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
+  plans: OntologyReplacementPlanStorage,
+  plan: ReplacementPlanRef,
   input: ProjectionReplacementPlanInput
-): Promise<EffectiveChangeCounts> {
-  const counts = emptyCounts()
+): Promise<void> {
+  const staged = { ...plan, commit: input.commit }
   if (input.projectionKind === "object") {
-    await planObjectReplacement(context, storage, session, input, counts)
+    for await (const page of plans.streamState({
+      ...plan,
+      entityKind: "object",
+      pageRows: context.batching.statePageRows,
+    })) {
+      throwIfAborted(input.signal)
+      await stagePlanned(
+        context,
+        plans,
+        staged,
+        page.objects.map((state) => ({
+          identity: { kind: "object", ref: state.ref },
+          records: planReplacementObject(context, input, state),
+        }))
+      )
+    }
   }
-  await planLinkReplacement(context, storage, session, input, counts)
-  await validateStagedCardinality(context, storage, session, input.signal)
-  return counts
-}
-
-async function planObjectReplacement(
-  context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
-  input: ProjectionReplacementPlanInput,
-  counts: MutableCounts
-): Promise<void> {
-  for await (const page of storage.streamSourceReplacementState({
-    session,
-    source: input.source,
-    candidateMaterializationId: input.materializationId,
-    entityKind: "object",
+  for await (const page of plans.streamState({
+    ...plan,
+    entityKind: "link",
     pageRows: context.batching.statePageRows,
   })) {
     throwIfAborted(input.signal)
-    const work = planObjectPage(context, input, page, counts)
-    await stageWorkBounded(context, storage, session, work)
+    const endpoints = new Map(
+      page.endpoints.map((endpoint) => [objectRefKey(endpoint.ref), endpoint.exists] as const)
+    )
+    await stagePlanned(
+      context,
+      plans,
+      staged,
+      page.links.map((state) => ({
+        identity: { kind: "link", ref: state.ref },
+        records: planReplacementLink(context, input, state, endpoints),
+      }))
+    )
   }
 }
 
-function planObjectPage(
-  context: MaterializerContext,
-  input: ProjectionReplacementPlanInput,
-  page: SourceReplacementStatePage,
-  counts: MutableCounts
-): MaterializationWorkRecord[] {
-  const work: MaterializationWorkRecord[] = []
-  for (const state of page.objects) {
-    work.push(...planReplacementObject(context, input, state, counts))
+async function stagePlanned(
+  context: Pick<MaterializerContext, "batching">,
+  plans: OntologyReplacementPlanStorage,
+  plan: Omit<StageReplacementPlanInput, "planned">,
+  planned: readonly PlannedReplacementIdentity[]
+): Promise<void> {
+  for await (const chunk of chunkBySize(planned, {
+    maxRows: context.batching.planChunkRows,
+    maxBytes: context.batching.planChunkBytes,
+    byteLength: (value) => utf8JsonByteLength(value.records),
+  })) {
+    await plans.stage({ ...plan, planned: chunk })
   }
-  return work
 }
 
 function planReplacementObject(
   context: MaterializerContext,
   input: ProjectionReplacementPlanInput,
-  state: SourceReplacementObjectState,
-  counts: MutableCounts
+  state: SourceReplacementObjectState
 ): MaterializationWorkRecord[] {
   const resolved = resolveReplacementObject(context, state)
   if (resolved) validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
@@ -120,8 +125,8 @@ function planReplacementObject(
   const change = diffEffectiveObject({
     before: state.effective,
     resolved,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt,
+    commitId: input.commit.id,
+    committedAt: input.commit.committedAt,
   })
   const sortKey = objectRefSortKey(state.ref)
   const work: MaterializationWorkRecord[] = [
@@ -137,131 +142,27 @@ function planReplacementObject(
     work.push({ kind: "incident-object", recordKey: `incident:${sortKey}`, ref: state.ref })
   }
 
-  if (!change) {
-    counts.objectsUnchanged += 1
-    return work
-  }
-
-  incrementObjectCount(counts, change.kind)
-  appendObjectChangeWork(work, sortKey, context, input, change)
+  if (!change) return work
+  appendObjectChangeWork(work, sortKey, change)
   return work
 }
 
 function appendObjectChangeWork(
   work: MaterializationWorkRecord[],
   sortKey: string,
-  context: Pick<MaterializerContext, "projectId">,
-  input: ProjectionReplacementPlanInput,
   change: EffectiveObjectChange
 ): void {
   const items: MaterializationPlanWorkItem[] = []
   appendEffectiveObjectWork(items, change)
   for (const item of items) work.push(planWork(item, sortKey))
-  work.push(
-    eventWork(
-      buildObjectMaterializationEventDraft({
-        projectId: context.projectId,
-        commitId: input.identity.commitId,
-        committedAt: input.identity.committedAt,
-        origin: input.origin,
-        correlationId: input.correlationId,
-        attribution: input.attribution,
-        change,
-      })
-    )
-  )
-}
-
-async function planLinkReplacement(
-  context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
-  input: ProjectionReplacementPlanInput,
-  counts: MutableCounts
-): Promise<void> {
-  for await (const page of storage.streamSourceReplacementState({
-    session,
-    source: input.source,
-    candidateMaterializationId: input.materializationId,
-    entityKind: "link",
-    pageRows: context.batching.statePageRows,
-  })) {
-    throwIfAborted(input.signal)
-    const endpointExistence = await loadEndpointExistence(context, storage, session, page)
-    const work = planLinkPage(context, input, page, endpointExistence, counts)
-    await stageWorkBounded(context, storage, session, work)
-  }
-}
-
-async function loadEndpointExistence(
-  context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
-  page: SourceReplacementStatePage
-): Promise<ReadonlyMap<string, boolean>> {
-  const endpointRefs = collectEndpointRefs(page.links)
-  const endpointExistence = new Map<string, boolean>()
-  for (const value of await storage.readObjectExistence({
-    session,
-    refs: [...endpointRefs.values()],
-  })) {
-    endpointExistence.set(objectRefKey(value.ref), value.exists)
-  }
-
-  const missingEndpoints = [...endpointRefs.values()].filter(
-    (ref) => !endpointExistence.has(objectRefKey(ref))
-  )
-  if (missingEndpoints.length === 0) return endpointExistence
-
-  for await (const endpointPage of storage.streamState({
-    session,
-    requests: oneStateRequest({
-      objects: missingEndpoints,
-      links: [],
-      linkScopes: [],
-      incidentObjects: [],
-      points: [],
-    }),
-    pageRows: context.batching.statePageRows,
-  })) {
-    for (const endpoint of endpointPage.objects) {
-      endpointExistence.set(objectRefKey(endpoint.ref), endpoint.effective !== null)
-    }
-  }
-  return endpointExistence
-}
-
-function collectEndpointRefs(
-  links: readonly SourceReplacementLinkState[]
-): ReadonlyMap<string, OntologyObjectRef> {
-  const refs = new Map<string, OntologyObjectRef>()
-  for (const state of links) {
-    refs.set(objectRefKey(state.ref.source), state.ref.source)
-    refs.set(objectRefKey(state.ref.target), state.ref.target)
-  }
-  return refs
-}
-
-function planLinkPage(
-  context: MaterializerContext,
-  input: ProjectionReplacementPlanInput,
-  page: SourceReplacementStatePage,
-  endpointExistence: ReadonlyMap<string, boolean>,
-  counts: MutableCounts
-): MaterializationWorkRecord[] {
-  const work: MaterializationWorkRecord[] = []
-  for (const state of page.links) {
-    work.push(...planReplacementLink(context, input, state, endpointExistence, counts))
-  }
-  return work
+  work.push(eventWork(buildObjectMaterializationEventDraft(change)))
 }
 
 function planReplacementLink(
   context: MaterializerContext,
   input: ProjectionReplacementPlanInput,
   state: SourceReplacementLinkState,
-  endpointExistence: ReadonlyMap<string, boolean>,
-  counts: MutableCounts
+  endpointExistence: ReadonlyMap<string, boolean>
 ): MaterializationWorkRecord[] {
   const resolved = resolveReplacementLink(context, state, endpointExistence)
   const work = cardinalityWork(context, state, resolved !== null)
@@ -270,18 +171,13 @@ function planReplacementLink(
   const change = diffEffectiveLink({
     before: state.effective,
     resolved,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt,
+    commitId: input.commit.id,
+    committedAt: input.commit.committedAt,
   })
   const sortKey = linkRefSortKey(state.ref)
   work.push(classificationWork("link", linkRefKey(state.ref), sortKey))
-  if (!change) {
-    counts.linksUnchanged += 1
-    return work
-  }
-
-  incrementLinkCount(counts, change.kind)
-  appendLinkChangeWork(work, sortKey, context, input, change)
+  if (!change) return work
+  appendLinkChangeWork(work, sortKey, change)
   return work
 }
 
@@ -348,26 +244,12 @@ function cardinalityWork(
 function appendLinkChangeWork(
   work: MaterializationWorkRecord[],
   sortKey: string,
-  context: Pick<MaterializerContext, "projectId">,
-  input: ProjectionReplacementPlanInput,
   change: EffectiveLinkChange
 ): void {
   const items: MaterializationPlanWorkItem[] = []
   appendEffectiveLinkWork(items, change)
   for (const item of items) work.push(planWork(item, sortKey))
-  work.push(
-    eventWork(
-      buildLinkMaterializationEventDraft({
-        projectId: context.projectId,
-        commitId: input.identity.commitId,
-        committedAt: input.identity.committedAt,
-        origin: input.origin,
-        correlationId: input.correlationId,
-        attribution: input.attribution,
-        change,
-      })
-    )
-  )
+  work.push(eventWork(buildLinkMaterializationEventDraft(change)))
 }
 
 function resolveReplacementObject(
@@ -383,30 +265,3 @@ function resolveReplacementObject(
     latestTelemetry: state.latestTelemetry,
   })
 }
-
-function emptyCounts(): MutableCounts {
-  return {
-    objectsCreated: 0,
-    objectsUpdated: 0,
-    objectsDeleted: 0,
-    objectsUnchanged: 0,
-    linksCreated: 0,
-    linksUpdated: 0,
-    linksDeleted: 0,
-    linksUnchanged: 0,
-  }
-}
-
-type MutableCounts = { -readonly [K in keyof EffectiveChangeCounts]: EffectiveChangeCounts[K] }
-
-function incrementObjectCount(counts: MutableCounts, kind: EffectiveObjectChange["kind"]): void {
-  if (kind === "created") counts.objectsCreated += 1
-  else if (kind === "updated") counts.objectsUpdated += 1
-  else counts.objectsDeleted += 1
-}
-
-function incrementLinkCount(counts: MutableCounts, kind: EffectiveLinkChange["kind"]): void {
-  if (kind === "created") counts.linksCreated += 1
-  else if (kind === "updated") counts.linksUpdated += 1
-  else counts.linksDeleted += 1
-}

package/src/materializer/shared/batching.ts

@@ -6,6 +6,11 @@ export interface MaterializationBatching {
   readonly statePageRows: number
   readonly planChunkRows: number
   readonly planChunkBytes: number
+  /**
+   * Stale identities a projection commit plans again inside its own transaction. A refresh that
+   * finds more gives them back to a round outside it.
+   */
+  readonly transactionReplanRows: number
 }
 
 export const DEFAULT_MATERIALIZATION_BATCHING: MaterializationBatching = Object.freeze({
@@ -17,6 +22,8 @@ export const DEFAULT_MATERIALIZATION_BATCHING: MaterializationBatching = Object.
   statePageRows: 1_000,
   planChunkRows: 1_000,
   planChunkBytes: 4 * 1024 * 1024,
+  // One state page: a few hundred milliseconds of planning while the commit holds its locks.
+  transactionReplanRows: 1_000,
 })
 
 /** Internal test/provider override. Application configuration never exposes these chunk targets. */

package/src/materializer/telemetry/append.ts

@@ -32,7 +32,7 @@ import {
   type MaterializerExecution,
   prepareMaterializerExecution,
 } from "../execution/scope"
-import { drainStagedEvents, drainStagedWork } from "../execution/work-executor"
+import { applyStagedWork } from "../execution/work-executor"
 import type { MaterializerCommand } from "../materializer"
 import {
   createProjectionTelemetryIdempotencyKey,
@@ -397,20 +397,9 @@ async function executeTelemetryTransaction(
     storage.ontology.materializations,
     session,
     command.input,
-    command.identity,
-    origin,
-    {
-      correlationId: command.execution.correlationId,
-      attribution: command.execution.attribution,
-    }
-  )
-  await drainStagedWork(context, storage, session)
-  const eventCount = await drainStagedEvents(
-    context,
-    storage.ontology.materializations,
-    session,
     command.identity
   )
+  const eventCount = await applyStagedWork(context, storage, session)
   const result: TelemetryCommitResult = {
     kind: "telemetry",
     commitId: command.identity.commitId,
@@ -475,7 +464,6 @@ function telemetryCommit(
     requestHash: command.identity.requestHash,
     executionId: command.execution.executionId,
     origin,
-    ...command.execution.attribution,
     ontologyRevision: command.ontologyRevision,
     intent: telemetryCommitIntent(command),
     committedAt: command.identity.committedAt,

package/src/materializer/telemetry/plan.ts

@@ -1,7 +1,6 @@
 import { stableJsonStringify } from "../../json"
 import { MaterializationObjectNotFoundError } from "../../materialization/errors"
 import type {
-  OntologyMaterializationOrigin,
   OntologyObjectRef,
   TelemetryAppend,
   TelemetryPointWrite,
@@ -29,7 +28,6 @@ import {
 import { diffEffectiveObject } from "../effective/diff"
 import { loadState, oneStateRequest } from "../effective/load-state"
 import { validateEffectiveObject } from "../effective/validate"
-import type { MaterializerAttribution } from "../execution/scope"
 import { stageWorkBounded } from "../execution/work-executor"
 import {
   appendEffectiveObjectWork,
@@ -62,13 +60,6 @@ interface TelemetryObjectGroup {
 interface TelemetryPlanContext {
   readonly input: TelemetryAppend
   readonly identity: TimedCommitIdentity
-  readonly origin: OntologyMaterializationOrigin
-  readonly event: TelemetryEventContext
-}
-
-interface TelemetryEventContext {
-  readonly correlationId: string
-  readonly attribution: MaterializerAttribution
 }
 
 export async function planTelemetryAppend(
@@ -76,12 +67,10 @@ export async function planTelemetryAppend(
   storage: OntologyMaterializationStorage,
   session: MaterializationSession,
   input: TelemetryAppend,
-  identity: TimedCommitIdentity,
-  origin: OntologyMaterializationOrigin,
-  event: TelemetryEventContext
+  identity: TimedCommitIdentity
 ): Promise<TelemetryPlanCounts> {
   const counts = emptyTelemetryCounts()
-  const planContext = { input, identity, origin, event }
+  const planContext = { input, identity }
   const objects = await loadTelemetryObjects(context, storage, session, input.points)
   const existingPoints = await loadExistingPoints(context, storage, session, input.points)
   for (const group of telemetryObjectGroups(input.points)) {
@@ -137,7 +126,7 @@ async function planTelemetryObject(
   for (let start = group.start; start < group.end; start += context.batching.statePageRows) {
     const end = Math.min(group.end, start + context.batching.statePageRows)
     const points = planContext.input.points.slice(start, end)
-    const work = planTelemetryChunk(context, planContext, points, existingPoints, latest, counts)
+    const work = planTelemetryChunk(planContext, points, existingPoints, latest, counts)
     await stageWorkBounded(context, storage, session, work)
   }
 
@@ -164,7 +153,6 @@ async function loadTelemetryObjects(
 }
 
 function planTelemetryChunk(
-  context: Pick<MaterializerContext, "projectId">,
   planContext: TelemetryPlanContext,
   points: readonly TelemetryPointWrite[],
   existingPoints: ReadonlyMap<string, StoredTelemetryPoint>,
@@ -173,7 +161,7 @@ function planTelemetryChunk(
 ): MaterializationWorkRecord[] {
   const work: MaterializationWorkRecord[] = []
   for (const point of points) {
-    work.push(...planTelemetryPoint(context, planContext, point, existingPoints, latest, counts))
+    work.push(...planTelemetryPoint(planContext, point, existingPoints, latest, counts))
   }
   return work
 }
@@ -205,7 +193,6 @@ async function loadExistingPoints(
 }
 
 function planTelemetryPoint(
-  context: Pick<MaterializerContext, "projectId">,
   planContext: TelemetryPlanContext,
   point: TelemetryPointWrite,
   existingPoints: ReadonlyMap<string, StoredTelemetryPoint>,
@@ -223,7 +210,7 @@ function planTelemetryPoint(
   } else {
     countTelemetryPointChange(counts, existing)
     work.push(planWork(telemetryPointUpsert(point, existing, planContext.identity), sortKey))
-    work.push(eventWork(buildTelemetryEvent(context, planContext, point)))
+    work.push(eventWork(buildTelemetryMaterializationEventDraft(point)))
   }
 
   updateLatestPoint(latest, point, existing, unchanged, planContext.identity)
@@ -282,15 +269,6 @@ function storedTelemetryPointWithUnit<T extends object>(
   return { ...point, unit }
 }
 
-function buildTelemetryEvent(
-  context: Pick<MaterializerContext, "projectId">,
-  planContext: TelemetryPlanContext,
-  point: TelemetryPointWrite
-) {
-  const eventContext = telemetryEventContext(context, planContext)
-  return buildTelemetryMaterializationEventDraft({ ...eventContext, point })
-}
-
 function updateLatestPoint(
   latest: Map<string, StoredTelemetryPoint>,
   point: TelemetryPointWrite,
@@ -341,26 +319,11 @@ async function stageTelemetryObjectPlan(
     const items: MaterializationPlanWorkItem[] = []
     appendEffectiveObjectWork(items, change)
     work.push(...items.map((item) => planWork(item, sortKey)))
-    const eventContext = telemetryEventContext(context, planContext)
-    work.push(eventWork(buildObjectMaterializationEventDraft({ ...eventContext, change })))
+    work.push(eventWork(buildObjectMaterializationEventDraft(change)))
   }
   await stageWorkBounded(context, storage, session, work)
 }
 
-function telemetryEventContext(
-  context: Pick<MaterializerContext, "projectId">,
-  planContext: TelemetryPlanContext
-) {
-  return {
-    projectId: context.projectId,
-    commitId: planContext.identity.commitId,
-    committedAt: planContext.identity.committedAt,
-    origin: planContext.origin,
-    correlationId: planContext.event.correlationId,
-    attribution: planContext.event.attribution,
-  }
-}
-
 function emptyTelemetryCounts(): MutableTelemetryPlanCounts {
   return {
     pointsCreated: 0,

package/src/models/audio/catalog.ts

@@ -0,0 +1,90 @@
+import type { ModelRef } from "../catalog"
+import { indexModelBindings } from "../catalog-index"
+import type { TranscriptionModel } from "./types"
+
+export interface TranscriptionModelEntry extends ModelRef {
+  readonly model: TranscriptionModel
+}
+
+export interface TranscriptionModelCatalog {
+  readonly default: TranscriptionModelEntry
+  list(): readonly TranscriptionModelEntry[]
+  getByRef(ref: ModelRef): TranscriptionModelEntry | null
+}
+
+export interface AudioModelCatalog {
+  readonly transcription?: TranscriptionModelCatalog
+}
+
+export interface AudioModelCatalogInput {
+  /** Ordered; the first entry is the default transcriber. */
+  readonly transcription?: readonly TranscriptionModel[]
+}
+
+export function createAudioCatalog(
+  input: AudioModelCatalogInput | undefined
+): AudioModelCatalog | undefined {
+  if (input === undefined) return undefined
+  if (
+    !input ||
+    typeof input !== "object" ||
+    Array.isArray(input) ||
+    !Array.isArray(input.transcription)
+  ) {
+    throw new TypeError(
+      "[Sixb] models.audio.transcription must be a nonempty array of transcription models."
+    )
+  }
+
+  const index = indexModelBindings(
+    input.transcription,
+    "audio.transcription",
+    assertTranscriptionModel
+  )
+  const [defaultEntry] = index.list()
+  if (!defaultEntry) {
+    throw new TypeError("[Sixb] models.audio.transcription must contain at least one model.")
+  }
+
+  return Object.freeze({ transcription: Object.freeze({ ...index, default: defaultEntry }) })
+}
+
+export function assertTranscriptionModel(model: unknown): asserts model is TranscriptionModel {
+  const candidate = model as Partial<TranscriptionModel> | null
+  const definition = candidate?.definition
+  if (
+    !candidate ||
+    !isValidId(candidate.providerId) ||
+    !isValidId(candidate.modelId) ||
+    typeof candidate.transcribe !== "function" ||
+    definition?.kind !== "transcription" ||
+    definition.providerId !== candidate.providerId ||
+    definition.modelId !== candidate.modelId
+  ) {
+    throw invalidModel()
+  }
+
+  if (!Number.isSafeInteger(definition.maxInputBytes) || definition.maxInputBytes <= 0) {
+    throw invalidModel()
+  }
+
+  const mediaTypes = definition.mediaTypes
+  if (
+    mediaTypes !== undefined &&
+    (!Array.isArray(mediaTypes) ||
+      mediaTypes.length === 0 ||
+      !mediaTypes.every((type) => typeof type === "string" && /^audio\/[a-z0-9.+-]+$/.test(type)))
+  ) {
+    throw invalidModel()
+  }
+}
+
+function isValidId(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0 && value.trim() === value
+}
+
+function invalidModel(): TypeError {
+  return new TypeError(
+    "[SixbModels] Invalid transcription model identity, definition or input limits."
+  )
+}