@sixb/core 0.1.20 → 0.1.22

package/src/objects/unique-violation.ts

@@ -0,0 +1,59 @@
+import { createSixbError, type SixbCodedError, withFailureMessage } from "../errors/internal"
+import type { ReadonlyJsonValue } from "../json"
+import { UniqueValueViolationError } from "../materialization/errors"
+
+/**
+ * The coded error a write reports when it would give a unique value to a second object, or
+ * `undefined` for any other error. Like its message, it names only the type and the property:
+ * never the value, nor the object that holds it.
+ */
+export function uniqueViolationError(
+  error: unknown,
+  details?: ReadonlyJsonValue
+): SixbCodedError | undefined {
+  if (!(error instanceof UniqueValueViolationError)) return undefined
+
+  return codedViolation(error.objectTypeId, error.propertyId, error.message, {
+    cause: error,
+    details,
+  })
+}
+
+/** The same coded error for a batch item that a continue-mode commit refused. */
+export function uniqueViolationItemError(item: UniqueViolation): SixbCodedError {
+  return codedViolation(item.objectTypeId, item.propertyId, item.message)
+}
+
+interface UniqueViolation {
+  readonly objectTypeId: string
+  readonly propertyId: string
+  readonly message: string
+}
+
+/**
+ * The error a create meets on a primary id an object its writer cannot see holds. It tells that the
+ * id is taken, as a unique value is, and nothing about the object.
+ */
+export function primaryIdTakenError(
+  objectTypeId: string,
+  primaryPropertyId: string
+): SixbCodedError {
+  return codedViolation(
+    objectTypeId,
+    primaryPropertyId,
+    `[Sixb] Another '${objectTypeId}' object already has this '${primaryPropertyId}'.`
+  )
+}
+
+function codedViolation(
+  objectTypeId: string,
+  propertyId: string,
+  message: string,
+  options: { readonly cause?: unknown; readonly details?: ReadonlyJsonValue } = {}
+): SixbCodedError {
+  const coded = createSixbError("object.unique_violation", message, {
+    ...(options.cause === undefined ? {} : { cause: options.cause }),
+    details: options.details ?? { objectTypeId, propertyId },
+  })
+  return withFailureMessage(coded, `Property '${objectTypeId}.${propertyId}' is unique.`)
+}

package/src/objects/vectors/handle.ts

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto"
-import { assertCanEdit } from "../../authorization"
 import { AuthorizationError } from "../../authorization/errors"
 import { MaterializationValidationError } from "../../materialization/errors"
 import type { PreparedObjectVector } from "../../materialization/vectors"
 import { sameEmbeddingModel } from "../../models/embedding-model"
 import { getOntologyMutationRuntime } from "../../runtime/ontology-mutations"
+import { assertCanEditType } from "../conditional-writes"
 import type { ExecutionObjectContext } from "../context"
 import {
   INDEXING_EMBEDDING_TIMEOUT_MS,
@@ -42,7 +42,7 @@ export function createObjectVectorHandle(
 
   return Object.freeze({
     async index(): Promise<void> {
-      assertCanEdit(ctx, ref.objectTypeId)
+      await assertCanEditType(ctx, ref.objectTypeId)
       await assertReadable()
       const mutations = getOntologyMutationRuntime(ctx)
       const model = ctx.embeddingModels?.getByRef({
@@ -84,7 +84,7 @@ export function createObjectVectorHandle(
         result.vectors[0]!,
         profileDefinition.model.definition.dimensions
       )
-      assertCanEdit(ctx, ref.objectTypeId)
+      await assertCanEditType(ctx, ref.objectTypeId)
       await assertReadable()
       await mutations.commitEdits({
         mode: "atomic",

package/src/ontology/builders.ts

@@ -352,6 +352,8 @@ type PropertyOptions = {
   required?: boolean
   nullable?: boolean
   primary?: true
+  /** At most one object of the type holds each value. */
+  unique?: true
   mode?: PropertyMode
   semanticType?: QuantitativeTypeId
   query?: PropertyQueryMetadata
@@ -378,6 +380,7 @@ type PropertyResult<
   FieldFromOptions<TOptions, "required", boolean> &
   FieldFromOptions<TOptions, "nullable", boolean> &
   FieldFromOptions<TOptions, "primary", true> &
+  FieldFromOptions<TOptions, "unique", true> &
   FieldFromOptions<TOptions, "mode", PropertyMode> &
   FieldFromOptions<TOptions, "semanticType", QuantitativeTypeId> &
   FieldFromOptions<TOptions, "query", PropertyQueryMetadata> &
@@ -408,7 +411,12 @@ export function prop<
   const TOptions extends PropertyOptions,
 >(id: TId, schema: TSchema, options: TOptions): PropertyResult<TId, TSchema, TOptions>
 export function prop(id: string, schema: Schema, options?: PropertyOptions): Property {
-  const { markings, ...rest } = options ?? {}
+  // Most properties carry no markings: skip the rest copy that only exists to drop the key.
+  if (!options || withoutMarkingsKey(options)) {
+    return { id, name: options?.name ?? id, schema, ...options }
+  }
+
+  const { markings, ...rest } = options
   return {
     id,
     name: options?.name ?? id,
@@ -420,6 +428,12 @@ export function prop(id: string, schema: Schema, options?: PropertyOptions): Pro
   }
 }
 
+function withoutMarkingsKey(
+  options: PropertyOptions
+): options is PropertyOptions & { markings?: undefined } {
+  return !("markings" in options)
+}
+
 // ── Link shorthand ──────────────────────────────────────────
 
 /**

package/src/ontology/docs-markdown.ts

@@ -24,7 +24,7 @@ export interface RenderOntologyDocsInput {
    * Marked properties the reader is not cleared for. Like the ontology API, docs still list them,
    * flagged, so the agent can say the information exists; their values cannot be read or queried.
    */
-  readonly restrictedPropertyIds?: (objectTypeId: string) => ReadonlySet<string>
+  readonly restrictedPropertyIds?: (objectTypeId: string) => ReadonlySet<string> | undefined
 }
 
 export interface OntologyDocsIndexEntry {
@@ -135,6 +135,7 @@ function renderProperties(
         code(property.id),
         withFlags(schemaLabel(property.schema, valueTypesById), [
           ...(property.primary ? ["primary key"] : []),
+          ...(property.unique ? ["unique"] : []),
           ...(property.required && !property.primary ? ["required"] : []),
           ...(property.nullable ? ["nullable"] : []),
           ...(property.mode === "telemetry" ? ["telemetry"] : []),

package/src/ontology/index.ts

@@ -64,8 +64,8 @@ export type {
   ValueType,
   ValueTypeRefSchema,
 } from "./types"
-export type { UserRef } from "./user-ref"
-export { userRef } from "./user-ref"
+export type { CurrentUserRef, UserRef } from "./user-ref"
+export { currentUser, userRef } from "./user-ref"
 
 // ── Registry ──────────────────────────────────────────────
 

package/src/ontology/json-schema.ts

@@ -3,6 +3,9 @@ import { OntologyValidationError } from "./errors"
 import type { SchemaOrRef } from "./refs"
 import type { Schema, ValueType } from "./types"
 
+// A user reference carries no name, so whoever reads the schema is told how one is written.
+const USER_REF_DESCRIPTION = 'A Sixb user, written {"type":"user","id":"<user-id>"}.'
+
 type DeepReadonly<T> = T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T
 
 export interface SchemaJsonField {
@@ -104,6 +107,7 @@ function schemaJsonSchema(
       case "userRef":
         return {
           type: "object",
+          description: USER_REF_DESCRIPTION,
           properties: {
             type: { type: "string", enum: ["user"] },
             id: { type: "string", minLength: 1 },

package/src/ontology/primitives.ts

@@ -1,5 +1,6 @@
 import type { QueryScalarKind } from "../objects/query/ir"
 import type { PrimitiveSchema } from "./types"
+import type { UniqueValueKind } from "./unique-values"
 
 /**
  * Yes/no decisions a primitive schema makes for rules that several modules share.
@@ -28,6 +29,8 @@ export interface PrimitiveTraits {
   readonly telemetry: boolean
   /** Allowed anywhere inside a shared Action parameter's schema. */
   readonly shareableParam: boolean
+  /** How `unique: true` values compare; `undefined` when the primitive cannot be unique. */
+  readonly unique: UniqueValueKind | undefined
 }
 
 const comparable = {
@@ -42,14 +45,22 @@ const comparable = {
 } as const
 
 const PRIMITIVE_TRAITS = {
-  string: { ...comparable, queryScalarKind: "string", text: true, contains: true },
-  uuid: { ...comparable, queryScalarKind: "uuid", contains: true },
-  integer: { ...comparable, queryScalarKind: "integer" },
-  double: { ...comparable, queryScalarKind: "double" },
-  decimal: { ...comparable, queryScalarKind: "decimal" },
-  date: { ...comparable, queryScalarKind: "date" },
-  timestamp: { ...comparable, queryScalarKind: "timestamp" },
-  boolean: { ...comparable, queryScalarKind: "boolean", sortable: false },
+  string: {
+    ...comparable,
+    queryScalarKind: "string",
+    text: true,
+    contains: true,
+    unique: "string",
+  },
+  uuid: { ...comparable, queryScalarKind: "uuid", contains: true, unique: "string" },
+  integer: { ...comparable, queryScalarKind: "integer", unique: "integer" },
+  // Unique values compare as exact keys: floating-point values are no identity, and decimals and
+  // instants stay out until one stored spelling per value is guaranteed.
+  double: { ...comparable, queryScalarKind: "double", unique: undefined },
+  decimal: { ...comparable, queryScalarKind: "decimal", unique: undefined },
+  date: { ...comparable, queryScalarKind: "date", unique: "string" },
+  timestamp: { ...comparable, queryScalarKind: "timestamp", unique: undefined },
+  boolean: { ...comparable, queryScalarKind: "boolean", sortable: false, unique: undefined },
   // Blob references are resolved through the object that holds them, never compared.
   fileRef: {
     queryScalarKind: undefined,
@@ -61,6 +72,7 @@ const PRIMITIVE_TRAITS = {
     facet: false,
     telemetry: false,
     shareableParam: false,
+    unique: undefined,
   },
   // User references match by identity, never against typed search input. They are not text, carry
   // no order, and stay out of telemetry and shared sessions, which cannot disclose who they point to.
@@ -74,6 +86,7 @@ const PRIMITIVE_TRAITS = {
     facet: true,
     telemetry: false,
     shareableParam: false,
+    unique: "userRef",
   },
 } as const satisfies Record<PrimitiveSchema, PrimitiveTraits>
 

package/src/ontology/registry.ts

@@ -14,6 +14,7 @@ import {
 import type { ObjectTypeWithPropertyTokens } from "./tokens"
 import { createLinkTokenMap, createPropertyTokenMap } from "./tokens"
 import type { ObjectType, Schema, ValueType } from "./types"
+import { type UniquePropertyDefinition, uniquePropertiesOf } from "./unique-values"
 import {
   validatePrimaryProperties,
   validatePropertyDefinitions,
@@ -179,6 +180,7 @@ export class OntologyRegistry implements OntologyDefinitionCatalog {
   private readonly valueTypesById = new Map<string, ValueType>()
   private readonly subTypesById = new Map<string, Set<string>>()
   private readonly primaryByTypeId: Map<string, string>
+  private readonly uniqueByTypeId = new Map<string, readonly UniquePropertyDefinition[]>()
 
   constructor(options: OntologyRegistryOptions) {
     const { objectTypes, valueTypes } = collectOntology(options.sources)
@@ -209,6 +211,7 @@ export class OntologyRegistry implements OntologyDefinitionCatalog {
         })
     }
     this.primaryByTypeId = validatePrimaryProperties(this.objectTypesById)
+    this.indexUniqueProperties()
   }
 
   // ── Public read API ──────────────────────────────────────
@@ -244,6 +247,11 @@ export class OntologyRegistry implements OntologyDefinitionCatalog {
     return id
   }
 
+  /** The unique properties of a type, its inherited ones included. Empty for an unknown type. */
+  listUniqueProperties(objectTypeId: string): readonly UniquePropertyDefinition[] {
+    return this.uniqueByTypeId.get(objectTypeId) ?? []
+  }
+
   /** Collect all transitive sub-types of the given object type id. */
   listSubTypes(objectTypeId: string): string[] {
     const result: string[] = []
@@ -314,6 +322,14 @@ export class OntologyRegistry implements OntologyDefinitionCatalog {
 
   // ── Private initialization ───────────────────────────────
 
+  /** Every write consults the unique properties of its type: resolve their kinds once. */
+  private indexUniqueProperties(): void {
+    for (const [typeId, objectType] of this.objectTypesById) {
+      const unique = uniquePropertiesOf(objectType, this.valueTypesById)
+      if (unique.length > 0) this.uniqueByTypeId.set(typeId, unique)
+    }
+  }
+
   /**
    * Build the subtype graph from `extends` and `parents` declarations.
    *

package/src/ontology/types.ts

@@ -262,6 +262,15 @@ export interface Property {
    * Validation and runtime enforcement are handled separately.
    */
   primary?: true
+  /**
+   * Declares that each value of this property belongs to at most one object of the type, like an
+   * email or an external key. A write that would give a value to a second object is refused, and
+   * `getBy(Type.p.prop, value)` finds the object holding a value.
+   *
+   * Values compare exactly (case-sensitive), and `null` or absent values never count. Only strings,
+   * uuids, integers, dates, enums and user references can be unique, and only `true` is accepted.
+   */
+  unique?: true
   /**
    * Runtime behavior of this property's value.
    *

package/src/ontology/unique-values.ts

@@ -0,0 +1,84 @@
+/**
+ * Keys of unique property values.
+ *
+ * A property declared `unique: true` holds each value on at most one object of its exact type.
+ * Storage compares the values through the keys computed here, so every provider matches them the
+ * same way: strings exactly (case-sensitive, no trimming or Unicode normalization), integers by
+ * their decimal form and user references by user id. `null` and absent values have no key: any
+ * number of objects may hold them.
+ */
+import { primitiveTraits } from "./primitives"
+import type { ObjectType, Schema, ValueType } from "./types"
+import { isUserRef } from "./user-ref"
+
+/** How the values of a unique property compare. */
+export type UniqueValueKind = "string" | "integer" | "userRef"
+
+/**
+ * The version of the keys below. Storage records the version each property was prepared with:
+ * changing how keys are computed means bumping it, which rebuilds every unique property.
+ */
+export const UNIQUE_VALUE_KEY_VERSION = 1
+
+/** A unique property of an object type. */
+export interface UniquePropertyDefinition {
+  readonly propertyId: string
+  readonly kind: UniqueValueKind
+}
+
+/**
+ * The kind of a schema that can be unique, through value types: strings, uuids, dates, integers,
+ * string and integer enums, and user references. `undefined` for every other schema.
+ */
+export function uniqueValueKind(
+  schema: Schema,
+  valueTypesById: ReadonlyMap<string, ValueType>,
+  seenValueTypeIds: ReadonlySet<string> = new Set()
+): UniqueValueKind | undefined {
+  if (typeof schema === "string") return primitiveTraits(schema)?.unique
+
+  if (schema.type === "enum") return schema.valueType === "integer" ? "integer" : "string"
+
+  if (schema.type !== "valueTypeRef" || seenValueTypeIds.has(schema.valueTypeId)) {
+    return undefined
+  }
+
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema
+  if (!resolved) return undefined
+
+  return uniqueValueKind(
+    resolved,
+    valueTypesById,
+    new Set([...seenValueTypeIds, schema.valueTypeId])
+  )
+}
+
+/** The unique properties of an object type, with how their values compare. */
+export function uniquePropertiesOf(
+  objectType: Pick<ObjectType, "properties">,
+  valueTypesById: ReadonlyMap<string, ValueType>
+): UniquePropertyDefinition[] {
+  const unique: UniquePropertyDefinition[] = []
+  for (const property of objectType.properties) {
+    if (!property.unique) continue
+    const kind = uniqueValueKind(property.schema, valueTypesById)
+    if (kind) unique.push({ propertyId: property.id, kind })
+  }
+  return unique
+}
+
+/**
+ * The key of a stored (validated and normalized) value, or `null` when the value claims nothing:
+ * `null`, absent, or not of the kind.
+ */
+export function uniqueValueKey(kind: UniqueValueKind, value: unknown): string | null {
+  switch (kind) {
+    case "string":
+      return typeof value === "string" ? value : null
+    // Integers beyond 2^53 lose precision as JSON numbers, but each still has one decimal form.
+    case "integer":
+      return Number.isInteger(value) ? String(value) : null
+    case "userRef":
+      return isUserRef(value) ? value.id : null
+  }
+}

package/src/ontology/user-ref.ts

@@ -35,6 +35,45 @@ export function isUserRef(value: unknown): value is UserRef {
   )
 }
 
+/**
+ * A `ref.user()` schema, or an array of them: the property schemas whose members a query can
+ * expand into profiles.
+ */
+export function isUserRefPropertySchema(schema: Schema): boolean {
+  if (schema === "userRef") return true
+  return typeof schema === "object" && schema.type === "array" && schema.items === "userRef"
+}
+
+/**
+ * The user reading, in a query predicate. The server binds it to the requester when the query runs:
+ * a query never stores or returns it.
+ */
+export type CurrentUserRef = { readonly type: "currentUser" }
+
+const CURRENT_USER: CurrentUserRef = Object.freeze({ type: "currentUser" })
+
+/**
+ * Match the user reading: `where(({ p }) => p.assignee.eq(currentUser()))`.
+ *
+ * Only query predicates on a `ref.user()` property accept it: `eq`, `neq`, `in`, and `contains`
+ * on a list of user references. It cannot be stored.
+ */
+export function currentUser(): CurrentUserRef {
+  return CURRENT_USER
+}
+
+/** Exactly `{ type: "currentUser" }`, the form `currentUser()` takes on the wire too. */
+export function isCurrentUser(value: unknown): value is CurrentUserRef {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false
+  const record = value as Record<string, unknown>
+  return Object.keys(record).length === 1 && record.type === "currentUser"
+}
+
+/** Why `subject` refuses `currentUser()`: it stands for the reader of a query, never for a value. */
+export function currentUserNotStorableMessage(subject: string): string {
+  return `${subject} cannot store currentUser(): it only stands for the user reading, in a query predicate. Store a user reference { type: "user", id } instead.`
+}
+
 /**
  * Collect the user ids a value holds at `userRef` positions of its schema, however deeply nested.
  *

package/src/ontology/validation/properties.ts

@@ -3,6 +3,7 @@ import type { ObjectLink, ObjectType, PrimitiveSchema, Property, Schema, ValueTy
 import { OntologyValidationError } from "../errors"
 import { primitiveTraits } from "../primitives"
 import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../tokens"
+import { uniqueValueKind } from "../unique-values"
 import { validateSchemaValue } from "./schema"
 
 export function assertObjectTypeRegistered(
@@ -170,6 +171,7 @@ export function validatePropertyDefinitions(
   for (const [typeId, objectType] of objectTypesById) {
     for (const property of objectType.properties) {
       assertNoObjectRefSchema(property, `Property '${typeId}.${property.id}'`, valueTypesById)
+      assertUniquePropertyDefinition(typeId, property, valueTypesById)
       if (property.mode !== "telemetry") continue
       // Telemetry stores time-series samples, not references, even when the reference is nested.
       const primitive = findPrimitiveSchema(
@@ -187,6 +189,11 @@ export function validatePropertyDefinitions(
       for (const property of link.properties ?? []) {
         const path = `Link property '${typeId}.${link.id}.${property.id}'`
         assertNoObjectRefSchema(property, path, valueTypesById)
+        if (property.unique) {
+          throw new OntologyValidationError(
+            `[Sixb] ${path} cannot be unique. Unique values are supported on object properties only.`
+          )
+        }
         // Link edits do not check that referenced users exist and are active.
         if (
           findPrimitiveSchema(property.schema, valueTypesById, (schema) => schema === "userRef")
@@ -200,6 +207,42 @@ export function validatePropertyDefinitions(
   }
 }
 
+/**
+ * A unique property is a static object property whose values compare as exact keys. Primary
+ * properties are unique by construction.
+ */
+function assertUniquePropertyDefinition(
+  typeId: string,
+  property: Property,
+  valueTypesById: ReadonlyMap<string, ValueType>
+): void {
+  if (!property.unique) return
+  const path = `Unique property '${typeId}.${property.id}'`
+
+  if (property.primary) {
+    throw new OntologyValidationError(
+      `[Sixb] ${path} is primary, and primary properties are already unique. Remove unique: true.`
+    )
+  }
+
+  if (property.mode === "telemetry") {
+    throw new OntologyValidationError(`[Sixb] ${path} cannot be a telemetry property.`)
+  }
+
+  if (uniqueValueKind(property.schema, valueTypesById) === undefined) {
+    throw new OntologyValidationError(
+      `[Sixb] ${path} cannot use ${schemaLabel(property.schema)}. ` +
+        "Unique values must be strings, uuids, integers, dates, enums or user references."
+    )
+  }
+}
+
+function schemaLabel(schema: Schema): string {
+  if (typeof schema === "string") return schema
+  if (schema.type === "valueTypeRef") return `value type '${schema.valueTypeId}'`
+  return schema.type
+}
+
 export function validatePropertyValue(
   property: Property,
   value: unknown,

package/src/ontology/validation/schema.ts

@@ -3,7 +3,7 @@ import { withFailureMessage } from "../../errors/failure-message"
 import type { ObjectFieldSchema, Schema, ValueType, ValueTypeRefSchema } from ".."
 import { isDecimalString } from "../decimal"
 import { OntologyValidationError } from "../errors"
-import { isUserRef } from "../user-ref"
+import { currentUserNotStorableMessage, isCurrentUser, isUserRef } from "../user-ref"
 
 /** Recursive schema validator used by both object and link property validation. */
 export function validateSchemaValue(
@@ -81,6 +81,14 @@ export function validateSchemaValue(
         return
       }
       case "userRef": {
+        if (isCurrentUser(value)) {
+          throw withFailureMessage(
+            new OntologyValidationError(
+              `[Sixb] ${currentUserNotStorableMessage(`Property ${path}`)}`
+            ),
+            currentUserNotStorableMessage(`Property ${diagnosticPath}`)
+          )
+        }
         if (!isUserRef(value)) {
           throw withFailureMessage(
             new OntologyValidationError(

package/src/pipelines/index.ts

@@ -1,5 +1,7 @@
+export { isDatasetPick } from "../datasets/builders"
 export { definePipeline, definePipelineStep } from "./builders"
 export { PipelineError } from "./errors"
+export { runStepLineage, stepInputColumns } from "./lineage"
 export type {
   PipelineRunRequestOptions,
   PipelineRunRequestResult,

package/src/pipelines/lineage.ts

@@ -0,0 +1,45 @@
+import type { DatasetDefinition } from "../datasets/types"
+import type { DatasetColumnLineage, DatasetColumnRef } from "../lake-storage/types"
+import { PipelineError } from "./errors"
+import type { PipelineStepDefinition } from "./types"
+
+/**
+ * Columns a step reads from one of its inputs: the columns of a `pick()`, otherwise every column of
+ * the dataset. Startup checks a pick against the registered dataset, and that any other input is
+ * the whole registered dataset.
+ */
+export function stepInputColumns(input: DatasetDefinition): readonly string[] {
+  return input.schema.columns.map((column) => column.name)
+}
+
+/**
+ * Lineage of a version written by a `run` step. Sixb cannot see what the handler computes, so
+ * every output column depends on every column the step reads.
+ */
+export function runStepLineage(
+  step: PipelineStepDefinition,
+  registeredDatasetsById: ReadonlyMap<string, DatasetDefinition>
+): DatasetColumnLineage {
+  const output = registeredDatasetsById.get(step.output.id)
+  if (!output) {
+    throw new PipelineError(
+      `[Sixb] Pipeline step '${step.id}' outputs unregistered dataset '${step.output.id}'.`
+    )
+  }
+
+  return {
+    rows: stepReadColumns(step),
+    columns: Object.fromEntries(output.schema.columns.map((column) => [column.name, []])),
+  }
+}
+
+/** Every column a step reads, once each, across all of its inputs. */
+export function stepReadColumns(step: PipelineStepDefinition): readonly DatasetColumnRef[] {
+  const refs = new Map<string, DatasetColumnRef>()
+  for (const input of Object.values(step.inputs)) {
+    for (const column of stepInputColumns(input)) {
+      refs.set(JSON.stringify([input.id, column]), { datasetId: input.id, column })
+    }
+  }
+  return [...refs.values()]
+}

package/src/projections/internal.ts

@@ -8,8 +8,8 @@ import type { ProjectionDispatchDescriptor } from "./types"
  * `projectionTargetOf` derives the object types a projection writes, to record them on the run.
  * `validateTelemetryProjectionFieldMapping` re-checks a telemetry mapping against the dataset schema
  * before writing. `parseDatasetTimestamp` keeps worker timestamps aligned with the materializer's
- * authoritative validation. These are plumbing, so they live here instead of on the
- * `@sixb/core` root.
+ * authoritative validation. These are plumbing, so they live here instead of on the `@sixb/core`
+ * root.
  */
 export { projectionTargetOf } from "./builders"
 export {