@sixb/core 0.1.2 → 0.1.4

package/src/storage/objects/in-memory.ts

@@ -1,6 +1,14 @@
 import type { EffectiveLinkSnapshot, EffectiveObjectSnapshot } from "../../materialization/model"
 import type { ObjectQuery, ObjectQueryPredicate, ObjectQuerySortField } from "../../objects/query"
 import { compareQueryScalarValues, queryScalarValuesEqual } from "../../objects/query/scalar-values"
+import type { LinkBatchKey, ObjectBatchKey } from "./keys"
+import {
+  compareObjectLinkCursors,
+  compareObjectLinks,
+  linkBatchKey,
+  objectBatchKey,
+  objectLinkCursor,
+} from "./keys"
 import type {
   CountObjectsInput,
   CountObjectsResult,
@@ -15,6 +23,8 @@ import type {
   ObjectQueryCapabilities,
   ObjectRow,
   ObjectStorage,
+  QueryObjectLinksInput,
+  QueryObjectLinksResult,
   QueryObjectsInput,
   QueryObjectsResult,
 } from "./types"
@@ -26,6 +36,7 @@ const IN_MEMORY_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
   facetObjects: true,
   nodes: {
     start: true,
+    refs: true,
     filter: true,
     text: true,
     vector: true,
@@ -80,25 +91,41 @@ const IN_MEMORY_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
 }
 
 function objectRowKey(projectId: string, objectTypeId: string): string {
-  return `${projectId}:${objectTypeId}`
+  return JSON.stringify([projectId, objectTypeId])
 }
 
-function comparePrimaryIds(left: string, right: string): number {
+function objectRowProjectPrefix(projectId: string): string {
+  return `[${JSON.stringify(projectId)},`
+}
+
+function compareStrings(left: string, right: string): number {
   if (left < right) return -1
   if (left > right) return 1
   return 0
 }
 
+function assertLinkQueryLimit(limit: number): void {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object link query limit must be a positive safe integer.")
+  }
+}
+
 function sourceLinkBucketKey(projectId: string, sourceTypeId: string, sourceId: string): string {
-  return `${projectId}:${sourceTypeId}:${sourceId}`
+  return JSON.stringify([projectId, sourceTypeId, sourceId])
 }
 
 function linkRowKey(linkId: string, targetTypeId: string, targetId: string): string {
-  return `${linkId}:${targetTypeId}:${targetId}`
+  return JSON.stringify([linkId, targetTypeId, targetId])
 }
 
 function fullLinkRowKey(row: ObjectLinkRow): string {
-  return `${row.sourceTypeId}:${row.sourceId}:${row.linkId}:${row.targetTypeId}:${row.targetId}`
+  return JSON.stringify([
+    row.sourceTypeId,
+    row.sourceId,
+    row.linkId,
+    row.targetTypeId,
+    row.targetId,
+  ])
 }
 
 type QueryEntry = {
@@ -343,6 +370,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
     switch (query.kind) {
       case "start":
         return this.evaluateStart(projectId, query.objectTypeId)
+      case "refs":
+        return this.evaluateRefs(projectId, query.refs)
       case "filter": {
         const input = this.evaluateObjectQuery(projectId, query.input)
         const entries = input.entries.filter((entry) =>
@@ -446,6 +475,29 @@ export class InMemoryObjectStorage implements ObjectStorage {
     return completeEvaluation(entries)
   }
 
+  private evaluateRefs(
+    projectId: string,
+    refs: readonly { objectTypeId: string; primaryId: string }[]
+  ): QueryEvaluation {
+    const seen = new Set<string>()
+    const entries = refs
+      .flatMap((ref) => {
+        const key = JSON.stringify([ref.objectTypeId, ref.primaryId])
+        if (seen.has(key)) return []
+        seen.add(key)
+        const row = this.rows.get(objectRowKey(projectId, ref.objectTypeId))?.get(ref.primaryId)
+        return row ? [row] : []
+      })
+      .sort(
+        (left, right) =>
+          compareStrings(left.objectTypeId, right.objectTypeId) ||
+          compareStrings(left.primaryId, right.primaryId)
+      )
+      .map((row, order) => ({ row, score: 0, order }))
+
+    return completeEvaluation(entries)
+  }
+
   private evaluateSet(
     projectId: string,
     op: "union" | "intersect" | "subtract",
@@ -602,8 +654,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
   async getByPrimaryIdBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; primaryId: string }[]
-  }): Promise<Map<string, ObjectRow>> {
-    const result = new Map<string, ObjectRow>()
+  }): Promise<Map<ObjectBatchKey, ObjectRow>> {
+    const result = new Map<ObjectBatchKey, ObjectRow>()
     for (const item of params.items) {
       const row = await this.getByPrimaryId({
         projectId: params.projectId,
@@ -611,7 +663,7 @@ export class InMemoryObjectStorage implements ObjectStorage {
         primaryId: item.primaryId,
       })
       if (row) {
-        result.set(`${item.objectTypeId}:${item.primaryId}`, row)
+        result.set(objectBatchKey(item.objectTypeId, item.primaryId), row)
       }
     }
     return result
@@ -620,8 +672,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
   async listLinksBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; objectId: string; linkId: string }[]
-  }): Promise<Map<string, ObjectLinkRow[]>> {
-    const result = new Map<string, ObjectLinkRow[]>()
+  }): Promise<Map<LinkBatchKey, ObjectLinkRow[]>> {
+    const result = new Map<LinkBatchKey, ObjectLinkRow[]>()
     for (const item of params.items) {
       const rows = await this.listLinks({
         projectId: params.projectId,
@@ -630,12 +682,48 @@ export class InMemoryObjectStorage implements ObjectStorage {
         linkId: item.linkId,
       })
       if (rows.length > 0) {
-        result.set(`${item.objectTypeId}:${item.objectId}:${item.linkId}`, [...rows])
+        result.set(linkBatchKey(item.objectTypeId, item.objectId, item.linkId), [...rows])
       }
     }
     return result
   }
 
+  async queryLinks(params: QueryObjectLinksInput): Promise<QueryObjectLinksResult> {
+    assertLinkQueryLimit(params.limit)
+    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+      return { links: [], hasMore: false }
+    }
+
+    const allowedTypes = params.endpointObjectTypeIds
+      ? new Set(params.endpointObjectTypeIds)
+      : undefined
+    const deduped = new Map<string, ObjectLinkRow>()
+    for (const object of params.objectRefs) {
+      const rows = await this.listLinks({
+        projectId: params.projectId,
+        objectTypeId: object.objectTypeId,
+        objectId: object.primaryId,
+        direction: params.direction,
+        ...(params.linkId === undefined ? {} : { linkId: params.linkId }),
+      })
+      for (const row of rows) {
+        if (
+          allowedTypes &&
+          (!allowedTypes.has(row.sourceTypeId) || !allowedTypes.has(row.targetTypeId))
+        ) {
+          continue
+        }
+        if (params.after && compareObjectLinkCursors(objectLinkCursor(row), params.after) <= 0) {
+          continue
+        }
+        deduped.set(fullLinkRowKey(row), row)
+      }
+    }
+
+    const rows = [...deduped.values()].sort(compareObjectLinks).slice(0, params.limit + 1)
+    return { links: rows.slice(0, params.limit), hasMore: rows.length > params.limit }
+  }
+
   async listIncidentLinksBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; objectId: string }[]
@@ -665,10 +753,9 @@ export class InMemoryObjectStorage implements ObjectStorage {
     const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId))
     const rows = [...(bucket?.values() ?? [])]
       .filter(
-        (row) =>
-          !params.afterPrimaryId || comparePrimaryIds(row.primaryId, params.afterPrimaryId) > 0
+        (row) => !params.afterPrimaryId || compareStrings(row.primaryId, params.afterPrimaryId) > 0
       )
-      .sort((left, right) => comparePrimaryIds(left.primaryId, right.primaryId))
+      .sort((left, right) => compareStrings(left.primaryId, right.primaryId))
       .slice(0, params.limit + 1)
     const hasMore = rows.length > params.limit
     const objects = rows.slice(0, params.limit).map((row) => structuredClone(row))
@@ -707,7 +794,7 @@ export class InMemoryObjectStorage implements ObjectStorage {
       }
     } else {
       for (const [key, bucket] of this.rows) {
-        if (key.startsWith(`${params.projectId}:`)) {
+        if (key.startsWith(objectRowProjectPrefix(params.projectId))) {
           allRows.push(...bucket.values())
         }
       }
@@ -1113,7 +1200,7 @@ function rowIdentityKey(row: ObjectRow): string {
 }
 
 function rowIdentityKeyParts(objectTypeId: string, primaryId: string): string {
-  return `${objectTypeId}:${primaryId}`
+  return objectBatchKey(objectTypeId, primaryId)
 }
 
 function upsertEntry(entriesByKey: Map<string, QueryEntry>, entry: QueryEntry): void {

package/src/storage/objects/index.ts

@@ -1,3 +1,9 @@
+export type { LinkBatchKey, ObjectBatchKey } from "./keys"
+export {
+  linkBatchKey,
+  objectBatchKey,
+  objectLinkCursor,
+} from "./keys"
 export type {
   CountObjectsInput,
   CountObjectsResult,
@@ -11,6 +17,7 @@ export type {
   ObjectFacetBucket,
   ObjectFacetRequest,
   ObjectFacetResult,
+  ObjectLinkCursor,
   ObjectLinkRow,
   ObjectQueryCapabilities,
   ObjectQueryCapabilityMap,
@@ -19,6 +26,8 @@ export type {
   ObjectRow,
   ObjectRowLinks,
   ObjectStorage,
+  QueryObjectLinksInput,
+  QueryObjectLinksResult,
   QueryObjectsInput,
   QueryObjectsResult,
 } from "./types"

package/src/storage/objects/keys.ts

@@ -0,0 +1,36 @@
+import type { ObjectLinkCursor, ObjectLinkRow } from "./types"
+
+export type ObjectBatchKey = string & {
+  readonly __sixbObjectBatchKey: true
+}
+
+export type LinkBatchKey = string & {
+  readonly __sixbLinkBatchKey: true
+}
+
+/** Collision-safe key for object batch-read results. */
+export function objectBatchKey(objectTypeId: string, primaryId: string): ObjectBatchKey {
+  return JSON.stringify([objectTypeId, primaryId]) as ObjectBatchKey
+}
+
+/** Collision-safe key for outgoing-link batch-read results. */
+export function linkBatchKey(objectTypeId: string, objectId: string, linkId: string): LinkBatchKey {
+  return JSON.stringify([objectTypeId, objectId, linkId]) as LinkBatchKey
+}
+
+/** Canonical storage ordering and cursor for physical links. */
+export function objectLinkCursor(link: ObjectLinkRow): ObjectLinkCursor {
+  return [link.sourceTypeId, link.sourceId, link.linkId, link.targetTypeId, link.targetId]
+}
+
+export function compareObjectLinkCursors(left: ObjectLinkCursor, right: ObjectLinkCursor): number {
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] < right[index]) return -1
+    if (left[index] > right[index]) return 1
+  }
+  return 0
+}
+
+export function compareObjectLinks(left: ObjectLinkRow, right: ObjectLinkRow): number {
+  return compareObjectLinkCursors(objectLinkCursor(left), objectLinkCursor(right))
+}

package/src/storage/objects/types.ts

@@ -6,6 +6,7 @@ import type {
   ObjectQuerySortField,
   QueryScalarKind,
 } from "../../objects/query"
+import type { LinkBatchKey, ObjectBatchKey } from "./keys"
 
 /**
  * Latest-state projection storage for objects and links.
@@ -64,6 +65,26 @@ export interface ObjectLinkRow {
 
 export type LinkDirection = "outgoing" | "incoming" | "both"
 
+/** Stable physical-link order: source type/id, link id, then target type/id. */
+export type ObjectLinkCursor = readonly [string, string, string, string, string]
+
+export interface QueryObjectLinksInput {
+  projectId: string
+  /** Object identities are treated as a set; duplicate refs do not duplicate links. */
+  objectRefs: readonly { objectTypeId: string; primaryId: string }[]
+  direction: LinkDirection
+  linkId?: string
+  /** When present, both endpoints must belong to this set. An empty set matches no links. */
+  endpointObjectTypeIds?: readonly string[]
+  after?: ObjectLinkCursor
+  limit: number
+}
+
+export interface QueryObjectLinksResult {
+  links: readonly ObjectLinkRow[]
+  hasMore: boolean
+}
+
 export type ObjectQueryCapabilityMap<T extends string> = Readonly<Partial<Record<T, boolean>>>
 
 export type ObjectQueryScalarOperation = "equality" | "ordering"
@@ -192,27 +213,34 @@ export interface ObjectStorage {
 
   /**
    * Batch fetch objects by (objectTypeId, primaryId) pairs.
-   * Returns a Map keyed by "objectTypeId:primaryId". Missing items are absent.
+   * Returns a Map keyed by {@link objectBatchKey}. Missing items are absent.
    */
   getByPrimaryIdBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; primaryId: string }[]
-  }): Promise<Map<string, ObjectRow>>
+  }): Promise<ReadonlyMap<ObjectBatchKey, ObjectRow>>
 
   /**
    * Batch fetch outgoing links by (objectTypeId, objectId, linkId) tuples.
-   * Returns a Map keyed by "objectTypeId:objectId:linkId". Missing entries are absent.
+   * Returns a Map keyed by {@link linkBatchKey}. Missing entries are absent.
    */
   listLinksBatch(params: {
     projectId: string
     items: readonly { objectTypeId: string; objectId: string; linkId: string }[]
-  }): Promise<Map<string, ObjectLinkRow[]>>
+  }): Promise<ReadonlyMap<LinkBatchKey, ObjectLinkRow[]>>
+
+  /**
+   * Read one canonical page of physical links incident to an object set.
+   * Filtering, endpoint-type scope, cursoring, ordering, and the limit are provider-owned so a
+   * bounded response never requires loading every incident link into the runtime.
+   */
+  queryLinks(params: QueryObjectLinksInput): Promise<QueryObjectLinksResult>
 
   /**
    * Batch fetch every link incident to any of the given objects, in BOTH directions (the object as
    * link source or target). Returns a flat, de-duplicated list: a physical link incident to two
-   * listed objects appears once. Used to load cascade-delete state for `object.delete` operations,
-   * which {@link listLinksBatch} cannot express because it keys on a specific linkId.
+   * listed objects appears once. This unpaged primitive exists for internal materialization and
+   * per-parent expansion work; interactive reads use {@link queryLinks}.
    */
   listIncidentLinksBatch(params: {
     projectId: string

package/src/storage/ontology/in-memory/materializations.ts

@@ -588,6 +588,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
             projectId,
             ref: item.ref,
             value: item.value,
+            editedAt: { ...item.editedAt },
             lastCommitId: item.lastCommitId,
             updatedAt: item.updatedAt,
           })

package/src/storage/ontology/materializations.ts

@@ -26,6 +26,8 @@ import type { StoredSourceLinkAssertion, StoredSourceObjectAssertion } from "./s
 export interface StoredObjectOverride {
   readonly ref: OntologyObjectRef
   readonly value: ObjectOverride
+  /** Per-property Action/runtime edit time. Legacy rows fall back to `updatedAt`. */
+  readonly editedAt?: Readonly<Record<string, string>>
   readonly lastCommitId: string
   readonly updatedAt: string
 }
@@ -160,6 +162,7 @@ export interface MaterializationPlanHeader {
 export interface ExactObjectOverrideWrite {
   readonly ref: OntologyObjectRef
   readonly value: ObjectOverride
+  readonly editedAt: Readonly<Record<string, string>>
   readonly expectedLastCommitId: string | null
   readonly lastCommitId: string
   readonly updatedAt: string

package/src/storage/ontology/provider-header-validation.ts

@@ -155,9 +155,9 @@ function assertProjectionTelemetryBatch(
   if (source.sourceRowsSkipped > source.sourceRowCount) {
     invalidCorrelation("Projection telemetry skipped rows exceed its source row count.")
   }
-  if (source.sourceRowCount !== inputPointCount + source.sourceRowsSkipped) {
+  if (inputPointCount < source.sourceRowCount - source.sourceRowsSkipped) {
     invalidCorrelation(
-      "Projection telemetry source row count does not match input points plus skipped rows."
+      "Projection telemetry input points do not account for every non-skipped source row."
     )
   }
   if (typeof source.inputExhausted !== "boolean") {

package/src/storage/operation-scope.ts

@@ -215,6 +215,7 @@ export function createAgentOperationScope<T extends AgentStorage>(
     threads: createOperationScopedFacade(target.threads, scope),
     runs: createOperationScopedFacade(target.runs, scope),
     messages: createOperationScopedFacade(target.messages, scope),
+    checkpoints: createOperationScopedFacade(target.checkpoints, scope),
   }) as T
 }
 

package/src/storage/types.ts

@@ -1,5 +1,6 @@
 import type { ActionRunStorage } from "./action-runs"
 import type { AgentStorage } from "./agents"
+import type { AiCostStorage } from "./ai-cost"
 import type { AiUsageStorage } from "./ai-usage"
 import type { AuthStorage } from "./auth"
 import type { ConnectorConnectionStorage } from "./connector-connections"
@@ -293,6 +294,7 @@ export interface Storage {
   auth?: AuthStorage
   agents?: AgentStorage
   aiUsage?: AiUsageStorage
+  aiCosts?: AiCostStorage
   actionRuns?: ActionRunStorage
   syncRuns?: SyncRunStorage
   pipelineRuns?: PipelineRunStorage