@sixb/core 0.1.2 → 0.1.4

package/src/materializer/edits/operations.ts

@@ -93,11 +93,13 @@ function applyObjectOperation(
     operation,
     sourceProperties: working.source?.assertion.properties ?? null,
     authority: working.override,
+    editedAt: working.editedAt,
+    committedAt: identity.committedAt,
     effectiveExists: currentEffective !== null,
     ...normalized,
   })
 
-  applyObjectTransition(context, state, working, transition.next, journal)
+  applyObjectTransition(context, state, working, transition.next, transition.editedAt, journal)
 
   return objectOperationOutcome(operation, working, transition.changed, context, identity)
 }
@@ -146,21 +148,26 @@ function applyObjectTransition(
   state: EditWorkingState,
   working: WorkingObject,
   next: WorkingObject["override"],
+  nextEditedAt: Readonly<Record<string, string>>,
   journal?: EditUndoJournal
 ): void {
   const previous = working.override
+  const previousEditedAt = working.editedAt
   working.override = next
+  working.editedAt = { ...nextEditedAt }
   try {
     const resolved = resolveObject(context.ontology, working)
     if (resolved) validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
     validateWorkingCardinality(state.links.slots)
   } catch (error) {
     working.override = previous
+    working.editedAt = previousEditedAt
     throw error
   }
   journal?.push({
     restore: () => {
       working.override = previous
+      working.editedAt = previousEditedAt
     },
   })
 }

package/src/materializer/edits/working-state.ts

@@ -25,6 +25,7 @@ import {
   resolveEffectiveLink,
   resolveEffectiveLinkSlot,
   resolveEffectiveObject,
+  storedObjectEditedAt,
   usableLinkSlotOverride,
 } from "../effective/resolve"
 import { linkCardinality } from "./read-set"
@@ -33,6 +34,8 @@ export interface WorkingObject {
   source: MaterializationObjectState["source"]
   originalOverride: StoredObjectOverride | null
   override: ObjectOverride | null
+  originalEditedAt: Readonly<Record<string, string>>
+  editedAt: Record<string, string>
   before: MaterializationObjectState["effective"]
   latestTelemetry: StoredTelemetryPoint[]
 }
@@ -112,11 +115,14 @@ function workingLinkSlotFromState(scope: MaterializationLinkScopeState): Working
 }
 
 export function workingObjectFromState(object: MaterializationObjectState): WorkingObject {
+  const editedAt = storedObjectEditedAt(object.override)
   return {
     ref: object.ref,
     source: object.source,
     originalOverride: object.override,
     override: object.override?.value ?? null,
+    originalEditedAt: editedAt,
+    editedAt: { ...editedAt },
     before: object.effective,
     latestTelemetry: [...object.latestTelemetry],
   }
@@ -141,6 +147,7 @@ export function resolveObject(
     primaryPropertyId: ontology.getPrimaryPropertyId(working.ref.objectTypeId),
     source: working.source,
     override: working.override,
+    editedAt: working.editedAt,
     latestTelemetry: working.latestTelemetry,
   })
 }

package/src/materializer/effective/resolve.ts

@@ -11,6 +11,7 @@ import type {
 import { linkRefKey } from "../../materialization/refs"
 import type {
   StoredLinkSlotOverride,
+  StoredObjectOverride,
   StoredSourceLinkAssertion,
   StoredSourceObjectAssertion,
   StoredTelemetryPoint,
@@ -46,9 +47,10 @@ export function resolveEffectiveObject(input: {
   readonly primaryPropertyId: string
   readonly source: StoredSourceObjectAssertion | null
   readonly override: ObjectOverride | null
+  readonly editedAt: Readonly<Record<string, string>>
   readonly latestTelemetry: readonly StoredTelemetryPoint[]
 }): ResolvedObjectValue | null {
-  const properties = resolveObjectAuthority(input.source, input.override)
+  const properties = resolveObjectAuthority(input.source, input.override, input.editedAt)
   if (!properties) return null
 
   properties[input.primaryPropertyId] = input.ref.primaryId
@@ -58,31 +60,98 @@ export function resolveEffectiveObject(input: {
 
 function resolveObjectAuthority(
   source: StoredSourceObjectAssertion | null,
-  override: ObjectOverride | null
+  override: ObjectOverride | null,
+  editedAt: Readonly<Record<string, string>>
 ): Record<string, JsonValue> | null {
   switch (override?.kind) {
     case "delete":
       return null
     case "create":
-      return { ...override.properties }
+      if (!source) return { ...override.properties }
+      return resolveSourceAndEdits(source, override, editedAt)
     case "patch":
       if (!source) return null
-      return applyObjectPatch(source.assertion.properties, override)
+      return resolveSourceAndEdits(source, override, editedAt)
     default:
       if (!source) return null
       return { ...source.assertion.properties }
   }
 }
 
-function applyObjectPatch(
-  sourceProperties: Readonly<Record<string, JsonValue>>,
-  override: Extract<ObjectOverride, { readonly kind: "patch" }>
+function resolveSourceAndEdits(
+  source: StoredSourceObjectAssertion,
+  override: Exclude<ObjectOverride, { readonly kind: "delete" }>,
+  editedAt: Readonly<Record<string, string>>
 ): Record<string, JsonValue> {
-  const properties = { ...sourceProperties, ...override.set }
-  for (const propertyId of override.unset) delete properties[propertyId]
+  const properties = { ...source.assertion.properties }
+  const absentSourcePropertyIds = new Set(source.assertion.absentSourcePropertyIds ?? [])
+
+  for (const propertyId of objectEditCandidateIds(override, editedAt)) {
+    const edit = objectEditCandidate(override, propertyId)
+    const editTimestamp = editedAt[propertyId]
+    const hasSourceCandidate =
+      Object.hasOwn(source.assertion.properties, propertyId) ||
+      absentSourcePropertyIds.has(propertyId)
+    const sourceWins =
+      hasSourceCandidate &&
+      source.assertion.sourceUpdatedAt !== undefined &&
+      editTimestamp !== undefined &&
+      source.assertion.sourceUpdatedAt.localeCompare(editTimestamp) >= 0
+
+    if (!sourceWins) applyObjectEditCandidate(properties, propertyId, edit)
+  }
   return properties
 }
 
+interface ObjectPropertyCandidate {
+  readonly present: boolean
+  readonly value?: JsonValue
+}
+
+function objectEditCandidateIds(
+  override: Exclude<ObjectOverride, { readonly kind: "delete" }>,
+  editedAt: Readonly<Record<string, string>>
+): string[] {
+  const ids = new Set(Object.keys(editedAt))
+  if (override.kind === "create") {
+    for (const propertyId of Object.keys(override.properties)) ids.add(propertyId)
+  } else {
+    for (const propertyId of Object.keys(override.set)) ids.add(propertyId)
+    for (const propertyId of override.unset) ids.add(propertyId)
+  }
+  return [...ids]
+}
+
+function objectEditCandidate(
+  override: Exclude<ObjectOverride, { readonly kind: "delete" }>,
+  propertyId: string
+): ObjectPropertyCandidate {
+  const values = override.kind === "create" ? override.properties : override.set
+  return Object.hasOwn(values, propertyId)
+    ? { present: true, value: values[propertyId] }
+    : { present: false }
+}
+
+function applyObjectEditCandidate(
+  properties: Record<string, JsonValue>,
+  propertyId: string,
+  candidate: ObjectPropertyCandidate
+): void {
+  if (candidate.present) properties[propertyId] = candidate.value as JsonValue
+  else delete properties[propertyId]
+}
+
+export function storedObjectEditedAt(stored: StoredObjectOverride | null): Record<string, string> {
+  if (!stored || stored.value.kind === "delete") return {}
+  const editedAt = { ...(stored.editedAt ?? {}) }
+  const candidateIds =
+    stored.value.kind === "create"
+      ? Object.keys(stored.value.properties)
+      : [...Object.keys(stored.value.set), ...stored.value.unset]
+  for (const propertyId of candidateIds) editedAt[propertyId] ??= stored.updatedAt
+  return editedAt
+}
+
 function applyLatestTelemetry(
   properties: Record<string, JsonValue>,
   latestTelemetry: readonly StoredTelemetryPoint[]

package/src/materializer/execution/work-records.ts

@@ -22,7 +22,8 @@ export function appendObjectOverrideWork(
 ): void {
   if (
     stableJsonStringify(working.originalOverride?.value ?? null) ===
-    stableJsonStringify(working.override)
+      stableJsonStringify(working.override) &&
+    stableJsonStringify(working.originalEditedAt) === stableJsonStringify(working.editedAt)
   ) {
     return
   }
@@ -32,6 +33,7 @@ export function appendObjectOverrideWork(
       value: {
         ref: working.ref,
         value: working.override,
+        editedAt: working.editedAt,
         expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
         lastCommitId: identity.commitId,
         updatedAt: identity.committedAt,

package/src/materializer/projections/entry-validator.ts

@@ -118,7 +118,29 @@ function validateObjectAssertion(
       `Projection '${resolved.projectionId}' asserted unowned property '${assertion.ref.objectTypeId}.${propertyId}'.`
     )
   }
-  return { ...assertion, properties }
+  const conflictResolution = resolved.definition.conflictResolution ?? { strategy: "editsWin" }
+  if (conflictResolution.strategy !== "mostRecent") {
+    return { kind: "object", ref: assertion.ref, properties }
+  }
+  if (assertion.sourceUpdatedAt === undefined) {
+    throw new MaterializationValidationError(
+      `Projection '${resolved.projectionId}' requires source update timestamp ` +
+        `'${conflictResolution.sourceTimestamp}' on every object assertion.`
+    )
+  }
+  const primaryPropertyId = ontology.getPrimaryPropertyId(assertion.ref.objectTypeId)
+  const absentSourcePropertyIds = [...owned]
+    .filter(
+      (propertyId) => propertyId !== primaryPropertyId && !Object.hasOwn(properties, propertyId)
+    )
+    .sort()
+  return {
+    kind: "object",
+    ref: assertion.ref,
+    properties,
+    sourceUpdatedAt: assertion.sourceUpdatedAt,
+    ...(absentSourcePropertyIds.length === 0 ? {} : { absentSourcePropertyIds }),
+  }
 }
 
 function validateLinkAssertion(

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

@@ -33,6 +33,7 @@ import {
   resolveEffectiveLink,
   resolveEffectiveLinkSlotMember,
   resolveEffectiveObject,
+  storedObjectEditedAt,
   usableLinkSlotOverride,
 } from "../effective/resolve"
 import { validateEffectiveObject } from "../effective/validate"
@@ -374,6 +375,7 @@ function resolveReplacementObject(
     primaryPropertyId: context.ontology.getPrimaryPropertyId(state.ref.objectTypeId),
     source: state.candidateSource,
     override: state.override?.value ?? null,
+    editedAt: storedObjectEditedAt(state.override),
     latestTelemetry: state.latestTelemetry,
   })
 }

package/src/materializer/shared/normalize.ts

@@ -25,6 +25,7 @@ import {
   projectionEntityKey,
   telemetryPointKey,
 } from "../../materialization/refs"
+import { parseDatasetTimestamp } from "../../projections/timestamp"
 
 export function normalizeJsonProperties(
   properties: Readonly<Record<string, unknown>>,
@@ -67,6 +68,16 @@ function normalizeTimestamp(value: string, label: string): string {
   return new Date(milliseconds).toISOString()
 }
 
+function normalizeProjectionSourceTimestamp(value: string): string {
+  const timestamp = parseDatasetTimestamp(value)
+  if (!timestamp) {
+    throw new MaterializationValidationError(
+      "Projection source update timestamp must be a valid timestamp."
+    )
+  }
+  return timestamp.toISOString()
+}
+
 function normalizePropertyIds(values: readonly string[], label: string): readonly string[] {
   const seen = new Set<string>()
   const normalized: string[] = []
@@ -347,6 +358,11 @@ function normalizeProjectionAssertion(
         kind: "object",
         ref: normalizeObjectRef(assertion.ref),
         properties: normalizeJsonProperties(assertion.properties),
+        ...(assertion.sourceUpdatedAt !== undefined
+          ? {
+              sourceUpdatedAt: normalizeProjectionSourceTimestamp(assertion.sourceUpdatedAt),
+            }
+          : {}),
       })
     : Object.freeze({
         kind: "link",

package/src/materializer/telemetry/append.ts

@@ -90,7 +90,6 @@ function prepareTelemetryAppend(
     points: raw.input.points.map((point) => validateTelemetryPoint(context.ontology, point)),
   })
   const inputPointCount = telemetryInputPointCount(input, rawInputPointCount)
-  validateTelemetryBatch(input, inputPointCount)
 
   const ontologyRevision = context.projectionRegistry.ontologyRevision
   const execution = prepareMaterializerExecution(context.projectId, raw.scope)
@@ -114,21 +113,6 @@ function telemetryInputPointCount(
   return input.points.length
 }
 
-function validateTelemetryBatch(input: NormalizedTelemetryAppend, inputPointCount: number): void {
-  if (input.source.kind === "projection") {
-    if (input.source.sourceRowCount === 0) {
-      throw new MaterializationValidationError(
-        "Projection telemetry batches must consume at least one source row; an empty dataset produces no batch commit."
-      )
-    }
-    if (input.source.sourceRowCount !== inputPointCount + input.source.sourceRowsSkipped) {
-      throw new MaterializationValidationError(
-        "Projection telemetry sourceRowCount must equal input points plus skipped rows."
-      )
-    }
-  }
-}
-
 function prepareRuntimeTelemetry(
   context: Pick<MaterializerContext, "projectId" | "clock">,
   input: NormalizedTelemetryAppend,
@@ -157,6 +141,7 @@ function prepareProjectionTelemetry(
   )
   validateTelemetryProjectionDataset(resolvedProjection, source)
   validateTelemetryOwnership(resolvedProjection, input)
+  validateTelemetryBatchCardinality(resolvedProjection, source, inputPointCount)
 
   const runIdentity = createProjectionRunMaterializationIdentity({
     resolved: resolvedProjection,
@@ -182,6 +167,38 @@ function prepareProjectionTelemetry(
   }
 }
 
+function validateTelemetryBatchCardinality(
+  resolved: ResolvedTelemetryProjection,
+  source: ProjectionTelemetrySource,
+  inputPointCount: number
+): void {
+  if (source.sourceRowCount === 0) {
+    throw new MaterializationValidationError(
+      "Projection telemetry batches must consume at least one source row; an empty dataset produces no batch commit."
+    )
+  }
+
+  const mappedPropertyCount = resolved.ownership.telemetry.length
+  if (mappedPropertyCount === 0) {
+    throw new MaterializationValidationError(
+      `Telemetry projection '${resolved.projectionId}' must own at least one telemetry property.`
+    )
+  }
+
+  const sourceRowsEmitted = source.sourceRowCount - source.sourceRowsSkipped
+  const maximumPointCount = sourceRowsEmitted * mappedPropertyCount
+  if (!Number.isSafeInteger(maximumPointCount)) {
+    throw new MaterializationValidationError(
+      `Telemetry projection '${resolved.projectionId}' batch point capacity exceeds the safe integer range.`
+    )
+  }
+  if (inputPointCount < sourceRowsEmitted || inputPointCount > maximumPointCount) {
+    throw new MaterializationValidationError(
+      `Telemetry projection '${resolved.projectionId}' must emit between ${sourceRowsEmitted} and ${maximumPointCount} points for ${source.sourceRowCount} source rows with ${source.sourceRowsSkipped} skipped.`
+    )
+  }
+}
+
 function validateTelemetryProjectionDataset(
   resolved: ResolvedTelemetryProjection,
   source: ProjectionTelemetrySource

package/src/models/index.ts

@@ -0,0 +1,71 @@
+import type { LanguageModelV4 } from "@ai-sdk/provider"
+import { createDefinitionCatalog, type DefinitionCatalog } from "../runtime/definitions"
+import { RuntimeError } from "../runtime/errors"
+
+/** The configured language models, with the project default. */
+export interface LanguageModelCatalog extends DefinitionCatalog<LanguageModelEntry> {
+  readonly default: LanguageModelEntry
+}
+
+/**
+ * One configured language model.
+ *
+ * `ref` is derived, never author-supplied, and stays internal to the runtime: it identifies the
+ * configured binding, not a vendor model. The AI SDK's `provider` names the binding, so
+ * `openai.chat(...)` and `openai.responses(...)` are distinct entries even for one vendor model,
+ * and neither matches the canonical id the worker resolves for billing
+ * (`SDK_PROVIDER_BINDINGS` in `@sixb/agent-worker`). Anything user-facing should key on
+ * `provider` + `modelId` instead.
+ */
+export interface LanguageModelEntry {
+  readonly ref: string
+  readonly provider: string
+  readonly modelId: string
+  readonly model: LanguageModelV4
+}
+
+/** Models a project allows Sixb to use, organized by technical model kind. */
+export interface ModelCatalog {
+  readonly language: LanguageModelCatalog
+}
+
+export interface ModelCatalogInput {
+  /** Ordered; the first entry is the project default. */
+  readonly language: readonly LanguageModelV4[]
+}
+
+/**
+ * Identify a catalog entry by the binding its model was constructed from.
+ *
+ * `gateway("openai/gpt-5.4")` and `openai("gpt-5.4")` are different entries on purpose: they route
+ * differently and bill differently. See {@link LanguageModelEntry}.
+ */
+export function modelRef(model: LanguageModelV4): string {
+  return `${model.provider}/${model.modelId}`
+}
+
+/** Build the immutable project model catalog. Rejects duplicates and an empty catalog. */
+export function createModelCatalog(input: ModelCatalogInput): ModelCatalog {
+  const byRef = new Map<string, LanguageModelEntry>()
+
+  for (const model of input.language) {
+    const ref = modelRef(model)
+    if (byRef.has(ref)) {
+      throw new RuntimeError(
+        `[Sixb] Duplicate language model '${ref}' in 'models'. Each provider and model id pair may be configured once.`
+      )
+    }
+    byRef.set(ref, Object.freeze({ ref, provider: model.provider, modelId: model.modelId, model }))
+  }
+
+  const [defaultEntry] = byRef.values()
+  if (defaultEntry === undefined) {
+    throw new RuntimeError(
+      "[Sixb] 'models.language' needs at least one model. Configure one or omit 'models' from createSixb()."
+    )
+  }
+
+  return Object.freeze({
+    language: Object.freeze({ ...createDefinitionCatalog(byRef), default: defaultEntry }),
+  })
+}

package/src/objects/execution.ts

@@ -29,8 +29,11 @@ import {
   type ExecuteObjectFacetsInput,
   type ExecuteObjectFacetsResult,
   type ExecuteObjectQueryInput,
+  type ExecuteObjectQueryLinksInput,
+  type ExecuteObjectQueryLinksResult,
   type ExecuteObjectQueryResult,
   executeObjectQuery,
+  executeObjectQueryLinks,
   existsObjects,
   facetObjects,
 } from "./query"
@@ -121,6 +124,12 @@ export interface ExecutionObjectSet<
   byId(id: string): ExecutionObjectByIdHandle<TObjectType, TValueTypes>
 }
 
+/** Public input for querying physical links incident to an object query result. */
+export type ObjectQueryLinksInput = Omit<ExecuteObjectQueryLinksInput, "projectId">
+
+/** Public result returned by {@link ObjectsRuntime.queryLinks}. */
+export type ObjectQueryLinksResult = ExecuteObjectQueryLinksResult
+
 export interface ObjectsRuntime<TOntologySources extends readonly OntologySource[]>
   extends ExecutionObjectOperations {
   <TObjectType extends RegisteredObjectType<TOntologySources>>(
@@ -131,6 +140,7 @@ export interface ObjectsRuntime<TOntologySources extends readonly OntologySource
     RegisteredObjectType<TOntologySources>
   >
   executeQuery(input: Omit<ExecuteObjectQueryInput, "projectId">): Promise<ExecuteObjectQueryResult>
+  queryLinks(input: ObjectQueryLinksInput): Promise<ObjectQueryLinksResult>
   count(input: Omit<ExecuteObjectCountInput, "projectId">): Promise<ExecuteObjectCountResult>
   exists(input: Omit<ExecuteObjectExistsInput, "projectId">): Promise<ExecuteObjectExistsResult>
   facet(input: Omit<ExecuteObjectFacetsInput, "projectId">): Promise<ExecuteObjectFacetsResult>
@@ -208,6 +218,16 @@ export function createObjectsRuntime<TOntologySources extends readonly OntologyS
             authorization: runtime.authorization,
           }
         ),
+      queryLinks: (input: ObjectQueryLinksInput) =>
+        executeObjectQueryLinks(
+          { projectId: runtime.projectId, ...input },
+          {
+            ontology: runtime.ontology,
+            storage: runtime.storage.objects,
+            runtimeAuthorization: runtime.runtimeAuthorization,
+            authorization: runtime.authorization,
+          }
+        ),
       count: (input: Omit<ExecuteObjectCountInput, "projectId">) =>
         countObjects(
           { projectId: runtime.projectId, ...input },

package/src/objects/link/endpoints.ts

@@ -7,6 +7,7 @@
  */
 
 import type { SixbRuntimeContext } from "../../runtime/types"
+import { objectBatchKey } from "../../storage"
 import { ObjectNotFoundError } from "../../storage/errors"
 
 export interface LinkEndpointItem {
@@ -62,5 +63,5 @@ export function requireEndpoints(item: LinkEndpointItem, existing: EndpointExist
 }
 
 function endpointKey(objectTypeId: string, primaryId: string): string {
-  return `${objectTypeId}:${primaryId}`
+  return objectBatchKey(objectTypeId, primaryId)
 }