@sixb/core 0.1.1 → 0.1.2

package/src/projections/capability.ts

@@ -0,0 +1,37 @@
+import type { ProjectionRegistry } from "./registry"
+import type { ProjectionDispatchDescriptor } from "./types"
+
+const projectionRegistryKey: unique symbol = Symbol("sixb.projectionRegistry")
+
+interface ProjectionRegistryOwner {
+  readonly [projectionRegistryKey]?: ProjectionRegistry
+}
+
+export function registerProjectionRegistry(owner: object, registry: ProjectionRegistry): void {
+  const registered = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
+  if (registered && registered !== registry) {
+    throw new Error("[Sixb] Projection registry is already registered for this owner.")
+  }
+  Object.defineProperty(owner, projectionRegistryKey, {
+    configurable: false,
+    enumerable: false,
+    value: registry,
+    writable: false,
+  })
+}
+
+export function getProjectionRegistry(owner: object): ProjectionRegistry {
+  const registry = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
+  if (registry) return registry
+  throw new Error("[Sixb] Projection registry is not registered for this runtime.")
+}
+
+export function getProjectionDispatchDescriptors(
+  owner: object
+): readonly ProjectionDispatchDescriptor[] {
+  return getProjectionRegistry(owner).getDispatchDescriptors()
+}
+
+export function shareProjectionRegistry(source: object, target: object): void {
+  registerProjectionRegistry(target, getProjectionRegistry(source))
+}

package/src/projections/execution.ts

@@ -0,0 +1,85 @@
+import { canViewProjection, canViewProjectionRun } from "../authorization"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type {
+  ListLatestProjectionRunsResult,
+  ListProjectionRunsInput,
+  ListProjectionRunsResult,
+  ProjectionRunRecord,
+} from "../storage/projection-runs"
+import type { ProjectionDefinitionCatalog } from "./registry"
+import type {
+  LinkProjectionDefinition,
+  ObjectProjectionDefinition,
+  ProjectionDefinition,
+  TelemetryProjectionDefinition,
+} from "./types"
+
+export interface ProjectionRunsRuntime {
+  getById(runId: string): Promise<ProjectionRunRecord | null>
+  list(
+    input?: Omit<ListProjectionRunsInput, "projectId" | "objectTypeIds">
+  ): Promise<ListProjectionRunsResult>
+  listLatest(projectionIds: readonly string[]): Promise<ListLatestProjectionRunsResult>
+}
+
+export interface ProjectionsRuntime {
+  list(): readonly ProjectionDefinition[]
+  listObjects(): readonly ObjectProjectionDefinition[]
+  listLinks(): readonly LinkProjectionDefinition[]
+  listTelemetry(): readonly TelemetryProjectionDefinition[]
+  getById(projectionId: string): ProjectionDefinition | null
+  readonly runs: ProjectionRunsRuntime
+}
+
+export function createProjectionsRuntime(
+  runtime: SixbRuntimeContext,
+  source: ProjectionDefinitionCatalog
+): ProjectionsRuntime {
+  const visible = (projection: ProjectionDefinition) =>
+    canViewProjection(runtime.authorization, projection)
+  const visibleIds = (projectionIds: readonly string[]) =>
+    projectionIds.filter((projectionId) => {
+      const projection = source.getById(projectionId)
+      return projection !== null && visible(projection)
+    })
+
+  return {
+    list: () => source.list().filter(visible),
+    listObjects: () => source.listObjects().filter(visible),
+    listLinks: () => source.listLinks().filter(visible),
+    listTelemetry: () => source.listTelemetry().filter(visible),
+    getById: (projectionId) => {
+      const projection = source.getById(projectionId)
+      return projection && visible(projection) ? projection : null
+    },
+    runs: {
+      getById: async (runId) => {
+        const run =
+          (await runtime.storage.projectionRuns?.getById({
+            projectId: runtime.projectId,
+            id: runId,
+          })) ?? null
+        return run && canViewProjectionRun(runtime.authorization, run.target) ? run : null
+      },
+      list: (input = {}) => {
+        const storage = runtime.storage.projectionRuns
+        if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        return storage.list({
+          projectId: runtime.projectId,
+          ...input,
+          objectTypeIds: runtime.authorization
+            ? [...runtime.authorization.grants["view:object"]]
+            : undefined,
+        })
+      },
+      listLatest: (projectionIds) => {
+        const storage = runtime.storage.projectionRuns
+        if (!storage || projectionIds.length === 0) return Promise.resolve({ runs: [] })
+        const ids = visibleIds(projectionIds)
+        return ids.length === 0
+          ? Promise.resolve({ runs: [] })
+          : storage.listLatestByProjectionIds({ projectId: runtime.projectId, projectionIds: ids })
+      },
+    },
+  }
+}

package/src/projections/index.ts

@@ -8,10 +8,11 @@ export {
   isObjectProjectionDefinition,
   isProjectionDefinition,
   isTelemetryProjectionDefinition,
-  projectionKindOf,
 } from "./builders"
 // ── Errors ──────────────────────────────────────────────────
 export { ProjectionValidationError } from "./errors"
+export type { ProjectionDefinitionCatalog, ProjectionRegistryOptions } from "./registry"
+export { ProjectionRegistry } from "./registry"
 // ── Types ────────────────────────────────────────────────────
 export type {
   ForeignKeyDescriptor,

package/src/projections/internal.ts

@@ -1,75 +1,32 @@
-import { sha256Canonical } from "../materialization/identity"
 import type { ProjectionMaterializationIdentity } from "../materialization/model"
 import type { ProjectionRegistry } from "./registry"
 import type { ProjectionDispatchDescriptor } from "./types"
 
-const projectionRegistryKey: unique symbol = Symbol("sixb.projectionRegistry")
-
-interface ProjectionRegistryOwner {
-  readonly [projectionRegistryKey]?: ProjectionRegistry
-}
-
-export function registerProjectionRegistry(owner: object, registry: ProjectionRegistry): void {
-  const registered = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
-  if (registered && registered !== registry) {
-    throw new Error("[Sixb] Projection registry is already registered for this owner.")
-  }
-
-  Object.defineProperty(owner, projectionRegistryKey, {
-    configurable: false,
-    enumerable: false,
-    value: registry,
-    writable: false,
-  })
-}
-
-export function getProjectionRegistry(owner: object): ProjectionRegistry {
-  const registry = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
-  if (registry) return registry
-  throw new Error("[Sixb] Projection registry is not registered for this runtime.")
-}
-
-/** Read-only orchestration view without exposing the registry capability to callers. */
-export function getProjectionDispatchDescriptors(
-  owner: object
-): readonly ProjectionDispatchDescriptor[] {
-  return getProjectionRegistry(owner).getDispatchDescriptors()
-}
-
-/** Copies the opaque registry capability when an internal runtime context is reconstructed. */
-export function shareProjectionRegistry(source: object, target: object): void {
-  registerProjectionRegistry(target, getProjectionRegistry(source))
-}
-
-export function createProjectionRunId(
-  projectId: string,
-  identity: ProjectionMaterializationIdentity
-): string {
-  return sha256Canonical({
-    projectId,
-    projectionId: identity.projectionId,
-    projectionKind: identity.projectionKind,
-    protocol: identity.protocol,
-    datasetId: identity.datasetVersion.datasetId,
-    versionId: identity.datasetVersion.versionId,
-    createdAt: identity.datasetVersion.createdAt,
-    ontologyRevision: identity.ontologyRevision,
-    projectionRevision: identity.projectionRevision,
-    ownershipHash: identity.ownershipHash,
-  })
-}
-
 /**
  * What the projection worker needs and an app author does not.
  *
  * `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. Both are plumbing, so they live here instead of on the `@sixb/core` root.
- *
- * `projectionKindOf` deliberately does not follow: nothing outside `packages/core` calls it, and a
- * subpath export with no importer is the dead surface this curation removes.
  */
 export { projectionTargetOf } from "./builders"
+export {
+  getProjectionDispatchDescriptors,
+  getProjectionRegistry,
+  registerProjectionRegistry,
+  shareProjectionRegistry,
+} from "./capability"
+export type {
+  ProjectionRunDispatcherDependencies,
+  ProjectionRunDispatchInput,
+  ProjectionRunDispatchPort,
+  ProjectionRunDispatchResult,
+} from "./run-dispatch"
+export {
+  PROJECTION_TELEMETRY_BATCH_SIZE,
+  ProjectionRunDispatcher,
+} from "./run-dispatch"
+export { createProjectionRunId } from "./run-id"
 export { validateTelemetryProjectionFieldMapping } from "./validation"
 
 export type { ProjectionDispatchDescriptor, ProjectionMaterializationIdentity, ProjectionRegistry }

package/src/projections/ownership.ts

@@ -1,11 +1,11 @@
 import { compareStrings } from "../json"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import { ProjectionValidationError } from "./errors"
 import type { ProjectionDefinition, ProjectionOwnership } from "./types"
 
 export function computeProjectionOwnership(
   projection: ProjectionDefinition,
-  ontology: OntologyRegistry
+  ontology: OntologyDefinitionCatalog
 ): ProjectionOwnership {
   if (projection._tag === "ObjectProjectionDefinition") {
     const primaryId = ontology.getPrimaryPropertyId(projection.objectTypeId)

package/src/projections/registry.ts

@@ -1,5 +1,5 @@
 import type { DatasetDefinition } from "../datasets"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import { isProjectionDefinition } from "./builders"
 import { ProjectionValidationError } from "./errors"
 import {
@@ -19,7 +19,22 @@ import { type ValidatedProjectionRecord, validateProjectionsAtStartup } from "./
 
 type SourceProjectionDefinition = ObjectProjectionDefinition | LinkProjectionDefinition
 
-export class ProjectionRegistry {
+/** Public definition catalog backed by the host's validated projection registry. */
+export interface ProjectionDefinitionCatalog {
+  list(): readonly ProjectionDefinition[]
+  getById(projectionId: string): ProjectionDefinition | null
+  listObjects(): readonly ObjectProjectionDefinition[]
+  listLinks(): readonly LinkProjectionDefinition[]
+  listTelemetry(): readonly TelemetryProjectionDefinition[]
+}
+
+export interface ProjectionRegistryOptions {
+  readonly projections: readonly ProjectionDefinition[]
+  readonly ontology: OntologyDefinitionCatalog
+  readonly datasetsById: ReadonlyMap<string, DatasetDefinition>
+}
+
+export class ProjectionRegistry implements ProjectionDefinitionCatalog {
   readonly ontologyRevision: string
   private readonly objectProjections: readonly ObjectProjectionDefinition[]
   private readonly linkProjections: readonly LinkProjectionDefinition[]
@@ -33,11 +48,7 @@ export class ProjectionRegistry {
   private readonly dispatchById = new Map<string, ProjectionDispatchDescriptor>()
   private readonly dispatchDescriptors: readonly ProjectionDispatchDescriptor[]
 
-  constructor(input: {
-    readonly projections: readonly ProjectionDefinition[]
-    readonly ontology: OntologyRegistry
-    readonly datasetsById: ReadonlyMap<string, DatasetDefinition>
-  }) {
+  constructor(input: ProjectionRegistryOptions) {
     const objectProjections: ObjectProjectionDefinition[] = []
     const linkProjections: LinkProjectionDefinition[] = []
     const telemetryProjections: TelemetryProjectionDefinition[] = []
@@ -103,19 +114,23 @@ export class ProjectionRegistry {
     }
   }
 
-  listObjectProjections(): readonly ObjectProjectionDefinition[] {
+  list(): readonly ProjectionDefinition[] {
+    return [...this.objectProjections, ...this.linkProjections, ...this.telemetryProjections]
+  }
+
+  listObjects(): readonly ObjectProjectionDefinition[] {
     return this.objectProjections
   }
 
-  listLinkProjections(): readonly LinkProjectionDefinition[] {
+  listLinks(): readonly LinkProjectionDefinition[] {
     return this.linkProjections
   }
 
-  listTelemetryProjections(): readonly TelemetryProjectionDefinition[] {
+  listTelemetry(): readonly TelemetryProjectionDefinition[] {
     return this.telemetryProjections
   }
 
-  getProjectionById(projectionId: string): ProjectionDefinition | null {
+  getById(projectionId: string): ProjectionDefinition | null {
     return this.projectionsById.get(projectionId) ?? null
   }
 

package/src/projections/revision.ts

@@ -1,11 +1,11 @@
 import type { DatasetDefinition } from "../datasets"
 import { compareStrings, type JsonValue } from "../json"
 import { sha256Canonical } from "../materialization/identity"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import type { ObjectFieldSchema, Property, Schema } from "../ontology/types"
 import type { ProjectionDefinition, ProjectionOwnership } from "./types"
 
-export function computeOntologyRevision(ontology: OntologyRegistry): string {
+export function computeOntologyRevision(ontology: OntologyDefinitionCatalog): string {
   const referencedValueTypeIds = collectOntologyValueTypeDependencies(ontology)
   return sha256Canonical({
     objectTypes: normalizeOntologyObjectTypes(ontology),
@@ -13,7 +13,9 @@ export function computeOntologyRevision(ontology: OntologyRegistry): string {
   })
 }
 
-function collectOntologyValueTypeDependencies(ontology: OntologyRegistry): ReadonlySet<string> {
+function collectOntologyValueTypeDependencies(
+  ontology: OntologyDefinitionCatalog
+): ReadonlySet<string> {
   const referencedValueTypeIds = new Set<string>()
   for (const objectType of ontology.getObjectTypesById().values()) {
     for (const property of objectType.properties) {
@@ -41,7 +43,7 @@ function collectOntologyValueTypeDependencies(ontology: OntologyRegistry): Reado
 }
 
 function normalizeOntologyValueTypes(
-  ontology: OntologyRegistry,
+  ontology: OntologyDefinitionCatalog,
   referencedValueTypeIds: ReadonlySet<string>
 ): JsonValue[] {
   return [...referencedValueTypeIds]
@@ -55,7 +57,7 @@ function normalizeOntologyValueTypes(
     }))
 }
 
-function normalizeOntologyObjectTypes(ontology: OntologyRegistry): JsonValue[] {
+function normalizeOntologyObjectTypes(ontology: OntologyDefinitionCatalog): JsonValue[] {
   return [...ontology.getObjectTypesById().values()]
     .sort((left, right) => compareStrings(left.id, right.id))
     .map((objectType) => ({