@sixb/core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sixb contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,470 @@
+# @sixb/core
+
+The ontology-first runtime for Sixb digital twins. Define your domain model in TypeScript, get a fully typed API for managing objects, links, telemetry, and actions.
+
+## Install
+
+```bash
+bun add @sixb/core
+```
+
+## Key Concepts
+
+**Ontology** -- Define your domain as object types with typed properties, links between types, and actions. Everything is expressed in TypeScript with full inference.
+
+**Runtime** -- `Sixb` is the main entry point. It registers your ontology and exposes a typed SDK (`sixb.objects(MyType)`) for reads, writes, telemetry, and links.
+
+**Storage** -- Pluggable backends for persistence and coordination. A Sixb runtime needs a `Broker`, `Storage`, `LakeStorage`, `BlobStorage`, and `Queues`. In-memory defaults are included for development and testing.
+
+**Lake Storage** -- Versioned datasets for table-shaped batch assets such as raw sync outputs, projections, and pipeline inputs/outputs. Lake providers store `fileRef` values as row metadata; blob payload bytes live in `BlobStorage`.
+
+**Blob Storage** -- Durable immutable binary objects referenced by dataset `fileRef` values. In-memory core support is included for development and tests; durable providers can be configured separately.
+
+**Events** -- All mutations are emitted to a bounded, retained event stream for live coordination and short replay. The runtime emits object/link mutation events such as `object.created`, `object.updated`, `object.deleted`, `link.created`, `link.updated`, and `link.deleted`, plus topic events like `telemetry.appended` and `action.requested`.
+
+**Actions** -- Typed audited commands. Actions can run external writeback, declare local object/link edits, and run post-commit effects.
+
+**Connectors** -- Typed external system clients that you register with the runtime and resolve lazily with `sixb.connector(...)`.
+
+**Syncs** -- Declarative batch sync definitions that read from one connector and write into one raw dataset. V1 supports `snapshot` and `append` modes with optional triggers and typed source checkpoints.
+
+**Queues** -- Typed durable work lanes for executable jobs such as sync runs, pipeline runs, and projection runs. App setup passes one `Queues` provider, while workers claim from lanes like `sixb.queues.syncRuns`.
+
+## Quick Start
+
+```ts
+import {
+  Sixb,
+  defineAction,
+  defineObjectType,
+  defineOntology,
+  InMemoryBlobStorage,
+  InMemoryLakeStorage,
+  link,
+  param,
+  prop,
+  stringEnum,
+  InMemoryBroker,
+  InMemoryQueues,
+  InMemoryStorage,
+} from "@sixb/core"
+
+// 1. Define object types
+
+const Room = defineObjectType({
+  id: "Room",
+  name: "Room",
+  properties: [
+    prop("id", "string", { required: true, primary: true }),
+    prop("externalId", "string", { required: true }),
+    prop("name", "string", { required: true }),
+    prop("currentTemperature", "double", {
+      mode: "telemetry",
+      semanticType: "Temperature",
+    }),
+  ],
+  links: [link.ref("hasThermostat", "Thermostat", { cardinality: "one" })],
+})
+
+const Thermostat = defineObjectType({
+  id: "Thermostat",
+  name: "Thermostat",
+  properties: [
+    prop("id", "string", { required: true, primary: true }),
+    prop("externalId", "string", { required: true }),
+    prop("name", "string", { required: true }),
+    prop("mode", stringEnum(["off", "heat", "cool", "auto"])),
+  ],
+})
+
+// 2. Group into an ontology (optional -- you can pass object types directly)
+
+const Buildings = defineOntology({
+  id: "buildings",
+  version: "1.0.0",
+  objectTypes: [Room, Thermostat],
+})
+
+// 3. Create the runtime
+
+const sixb = new Sixb({
+  id: "building-a",
+  ontology: [Buildings],
+  broker: new InMemoryBroker(),
+  storage: new InMemoryStorage(),
+  lakeStorage: new InMemoryLakeStorage(),
+  blobStorage: new InMemoryBlobStorage(),
+  queues: new InMemoryQueues(),
+})
+
+// 4. Use the typed SDK
+
+const room = await sixb.objects(Room).upsert({
+  properties: {
+    id: "room:101",
+    externalId: "RM-101",
+    name: "Conference 101",
+  },
+})
+
+const tstat = await sixb.objects(Thermostat).upsert({
+  properties: {
+    id: "tstat:abc",
+    externalId: "device-123",
+    name: "Tstat 101",
+  },
+})
+
+// Link objects
+await sixb.objects(Room).byId("room:101").link(Room.l.hasThermostat, tstat)
+
+// Append telemetry (unit is required because of semanticType: "Temperature")
+await sixb.objects(Room).byId("room:101").telemetry(Room.p.currentTemperature).append({
+  value: 22.4,
+  unit: "degreeCelsius",
+  at: new Date(),
+})
+
+// Query
+const found = await sixb
+  .objects(Room)
+  .query()
+  .where((r) => r.p.externalId.eq("RM-101"))
+  .first()
+```
+
+## Actions
+
+Actions define typed commands that can be requested globally or for an object subject.
+Local object/link mutations are declared in `.edits(...)` and committed by the action worker.
+
+```ts
+const renameRoom = defineAction("renameRoom")
+  .on(Room)
+  .params({
+    name: param("string"),
+  })
+  .validate(({ params }) => {
+    if (!params.name.trim()) {
+      return { error: "Name is required" }
+    }
+  })
+  .edits(({ objects, params, subject }) => {
+    objects(Room).byId(subject.primaryId).update({
+      name: params.name,
+    })
+  })
+
+await sixb.actions.request({
+  actionId: "renameRoom",
+  subject: { kind: "object", objectTypeId: "Room", primaryId: "room:101" },
+  params: { name: "Boardroom 101" },
+})
+```
+
+## Connectors
+
+Connectors are registered definitions. The runtime only creates the client when you resolve one with `sixb.connector(...)`.
+
+```ts
+import { defineConnector } from "@sixb/core"
+
+const erpDb = defineConnector("erpDb", {
+  type: "sql",
+  connect() {
+    return {
+      query(sql: string) {
+        return sql
+      },
+    }
+  },
+})
+
+const sixb = new Sixb({
+  ontology: [Room],
+  broker: myBroker,
+  storage: myStorage,
+  queues: myQueues,
+  connectors: [erpDb],
+})
+
+const db = await sixb.connector(erpDb)
+await db.query("select 1")
+```
+
+Connector adapters can also expose inbound webhooks. Webhooks are connector-scoped, discovered
+with their connector from `connectors/`, and served by `@sixb/server` at
+`POST /api/webhooks/:connectorId/:webhookId`.
+
+```ts
+import { defineConnector, defineWebhook, webhookConnector } from "@sixb/core"
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+const edgeGateway = defineConnector(
+  "edgeGateway",
+  webhookConnector({
+    webhooks: [
+      defineWebhook("telemetry")
+        .post()
+        .json({
+          parse(value: unknown) {
+            if (!isRecord(value) || typeof value.deviceId !== "string") {
+              throw new Error("deviceId is required")
+            }
+
+            if (value.temperature !== undefined && typeof value.temperature !== "number") {
+              throw new Error("temperature must be a number")
+            }
+
+            return {
+              deviceId: value.deviceId,
+              temperature: value.temperature,
+            }
+          },
+        })
+        .idempotencyKey(({ request }) => request.headers.get("x-delivery-id"))
+        .handle(async ({ body, sixb, logger }) => {
+          logger.info("Received device telemetry", { deviceId: body.deviceId })
+          await sixb.upsertObject("Device", {
+            id: body.deviceId,
+            temperature: body.temperature,
+          })
+        }),
+    ],
+  })
+)
+```
+
+Use `.json(schema)` for JSON bodies so payloads are validated at runtime. The `.verify(...)`,
+`.idempotencyKey(...)`, and `.handle(...)` callbacks each receive a run-scoped `logger`. Omit
+`.idempotencyKey(...)` for deterministic upserts where duplicate provider deliveries are harmless.
+
+## Syncs
+
+Syncs are declarative definitions in `@sixb/core` v1. They do not start background work on their own; they just declare how to read from a connector into a dataset.
+
+```ts
+import { col, defineDataset, defineSync } from "@sixb/core"
+
+const rawOrdersDataset = defineDataset("raw.erp.orders", {
+  schema: [
+    col("orderId", "string"),
+    col("customerId", "string", { nullable: true }),
+  ],
+})
+
+const rawOrderEventsDataset = defineDataset("raw.erp.order-events", {
+  schema: [col("eventId", "string")],
+})
+
+const syncOrders = defineSync("sync-orders")
+  .from(erpDb)
+  .read(({ query }) => query("select * from orders"))
+  .intoDataset(rawOrdersDataset)
+
+const syncOrderEvents = defineSync("sync-order-events", { mode: "append" })
+  .checkpoint<{ cursor: string }>()
+  .from(erpDb)
+  .read(({ query }, context) => {
+    const cursor = context.checkpoint?.cursor ?? "0"
+    context.setCheckpoint({ cursor: String(Number(cursor) + 1) })
+    return query(`select * from order_events where cursor > ${cursor}`)
+  })
+  .intoDataset(rawOrderEventsDataset)
+
+const sixb = new Sixb({
+  ontology: [Room],
+  broker: myBroker,
+  storage: myStorage,
+  queues: myQueues,
+  datasets: [rawOrdersDataset, rawOrderEventsDataset],
+  connectors: [erpDb],
+  syncs: [syncOrders, syncOrderEvents],
+})
+
+sixb.listSyncs()
+sixb.getSyncById("sync-orders")
+```
+
+Call `.checkpoint<T>()` before `.from(...)` to type `context.checkpoint` and
+`context.setCheckpoint(...)` in a sync read handler. The sync worker loads the checkpoint from the
+latest successful run and stores the next checkpoint only after the dataset commit succeeds.
+
+## Convention-based Setup
+
+`createSixb` auto-discovers ontology from `./ontology/`, datasets from `./datasets/`, syncs from `./syncs/`, workflows from `./workflows/`, and connectors from `./connectors/` in your project directory. Webhooks are discovered through their connector definitions.
+
+```ts
+import { createSixb } from "@sixb/core"
+
+const sixb = await createSixb({
+  id: "building-a",
+  broker: myBroker,
+  storage: myStorage,
+  lakeStorage: myLakeStorage,
+  blobStorage: myBlobStorage,
+  queues: myQueues,
+})
+```
+
+## Migrations
+
+`@sixb/core/storage` provides the storage-provider migration model used by the CLI and durable adapters (`migrateStorage` itself is also exported from the root):
+
+```ts
+import { migrateStorage } from "@sixb/core"
+import { defineMigrations, runMigrationSet, step } from "@sixb/core/storage"
+
+export const objectStorageMigrations = defineMigrations({
+  adapterId: "MyObjectStorage",
+  steps: [
+    step("001-initial-schema", async (db) => {
+      await db.exec("CREATE TABLE objects (...)")
+    }),
+  ],
+})
+```
+
+- `defineMigrations(...)` validates ordered migration sets and derives versions from ids like `001-initial-schema`.
+- `runMigrationSet(...)` plans pending work from migration history, blocks dirty or mismatched history, and returns a report.
+- `migrateStorage(storage)` runs a storage provider's exposed `migrators` when available.
+
+## Package Structure
+
+```
+src/
+  ontology/         -- type builders, schema, tokens, validation, units, inference
+  events/           -- domain event runtime, types, and helpers
+  broker/           -- retained stream provider contract and in-memory implementation
+  storage/          -- ObjectStorage and TimeseriesStorage interfaces
+    migrations/     -- shared migration runner types/utilities
+    objects/        -- object/link storage types and in-memory implementation
+    timeseries/     -- timeseries storage types and in-memory implementation
+  blob-storage/     -- BlobStorage types and in-memory implementation
+  lake-storage/     -- LakeStorage types and in-memory implementation
+  queues/           -- Queues, typed queue lanes, and in-memory implementation
+  connectors/       -- defineConnector, connector types, connector runtime
+  syncs/            -- defineSync and sync types
+  sixb/            -- Sixb runtime, ObjectSet, ObjectByIdHandle, createSixb
+  actions/          -- defineAction, param, optional, ActionRegistry
+```
+
+## API Overview
+
+### Ontology Builders
+
+| Export | Description |
+|---|---|
+| `defineObjectType(input)` | Define an object type with properties and links |
+| `defineOntology(input)` | Group object types and value types into a versioned document |
+| `defineValueType(input)` | Define a reusable value type |
+| `defineInterface(input)` | Define a reusable interface contract |
+| `prop(id, schema, options?)` | Shorthand for creating a property |
+| `link(id, target, options?)` | Create a link to direct ObjectType target(s) |
+| `link.ref(id, targetTypeId, options?)` | Create an id-only link reference |
+| `link.self(id, options?)` | Create a self-link |
+| `link.any(id, options?)` | Create a wildcard link |
+| `stringEnum(values)` | Create a string enum schema |
+| `integerEnum(values)` | Create an integer enum schema |
+| `valueTypeRef(valueType)` | Reference a value type in a property schema |
+
+### Action Builders
+
+| Export | Description |
+|---|---|
+| `defineAction(id)` | Define a first-class phased action contract |
+| `param(schema, options?)` | Define a required action parameter; `{ nullable: true }` accepts explicit `null` |
+| `optional(param(...))` | Mark an action parameter as optional while preserving nullable/value semantics |
+
+### Runtime
+
+| Export | Description |
+|---|---|
+| `Sixb` | Main runtime class |
+| `createSixb(options)` | Convention-based factory with auto-discovery |
+| `InMemoryQueues` | In-memory `Queues` provider with typed sync and pipeline lanes |
+| `InMemoryBlobStorage` | In-memory `BlobStorage` provider for `fileRef` payloads |
+| `migrateStorage(storage)` | Run configured storage migrations when supported |
+| `defineConnector(id, adapter)` | Define a connector for an external system |
+| `defineWebhook(id)` | Define an inbound connector webhook |
+| `webhookConnector(options)` | Define an inbound-only connector adapter |
+| `defineSync(id, options?)` | Define a batch sync from a connector into a dataset |
+
+### ObjectSet API (`sixb.objects(Type)`)
+
+| Method | Description |
+|---|---|
+| `.upsert({ properties })` | Create or update an object (id derived from primary property) |
+| `.get(id)` | Get an object by id |
+| `.query().where(...).limit(...).list()` | Execute a typed object query |
+| `.query().where(...).first()` | Return the first object from a typed query |
+| `.list({ limit, offset, ... })` | List stored objects with storage-system filtering and pagination |
+| `.byId(id)` | Get a handle for link/telemetry/action operations |
+| `.appendTelemetryBatch(items)` | Batch append telemetry for multiple objects |
+| `.requestAction({ actionId, params })` | Request an action on an object |
+
+### ObjectByIdHandle API (`sixb.objects(Type).byId(id)`)
+
+| Method | Description |
+|---|---|
+| `.get()` | Get the object |
+| `.link(token, target)` | Create or update a link |
+| `.unlink(token, target)` | Remove a link |
+| `.listLinks(token?)` | List links from this object |
+| `.telemetry(token)` | Get a telemetry appender for a property |
+| `.requestAction({ actionId, params })` | Request an action |
+
+### Storage And Queue Interfaces
+
+| Interface | Description |
+|---|---|
+| `Broker` | Retained stream provider used by runtime services |
+| `EventsRuntime` | Project-scoped domain event API with append, read, latest-cursor, and subscribe |
+| `ObjectStorage` | Latest-state projection storage for objects and links |
+| `TimeseriesStorage` | Time-series storage for telemetry history |
+| `BlobStorage` | Content-addressed binary storage with streaming `put` and `open` operations |
+| `MigrationSet<TContext>` | Ordered migration steps owned by one durable adapter |
+| `MigrationHistoryStore` | Provider-owned persistence for migration history records |
+| `StorageMigrator` | Plan and run one adapter's migration set |
+| `MigrationCapableStorage` | Optional storage capability exposing adapter migrators |
+| `Queues` | Queue provider with typed job lanes |
+| `Queue<TQueueJob>` | One typed queue lane with lease-based claim/complete/retry/fail semantics |
+
+In-memory implementations included: `InMemoryBroker`, `InMemoryObjectStorage`,
+`InMemoryTimeseriesStorage`, `InMemoryBlobStorage`, `InMemoryQueues`.
+
+### Events
+
+Domain events include object/link mutations (`object.created`, `object.updated`, `object.deleted`, `link.created`, `link.updated`, `link.deleted`) and topic events such as `telemetry.appended`, `action.requested`, `schedule.triggered`, `sync.run.finished`, `pipeline.run.finished`, and `dataset.version.committed`.
+
+### Units
+
+Built-in quantitative type and unit registry. Use `semanticType` on properties to constrain valid units.
+
+```ts
+import { isValidUnit, getUnit, quantitativeTypes } from "@sixb/core"
+
+isValidUnit("Temperature", "degreeCelsius") // true
+getUnit("degreeCelsius")?.symbol            // "°C"
+```
+
+## Runtime Validation
+
+The runtime validates all writes at runtime even if TypeScript checks are bypassed:
+
+- Every object type must have exactly one `primary` property (required, string schema)
+- Unknown properties are rejected
+- Required properties are enforced
+- Property values are validated against their schema
+- Telemetry values and units are validated against `semanticType`
+- Link target types and cardinality are validated
+- Action params are validated against the action definition
+
+## Notes
+
+- `ontology` accepts either object types directly or ontology documents
+- Object types support `extends` for single-inheritance and `parents` for multi-parent classification
+- This package is under active development; API may evolve

package/dist/actions/builders/define-action.d.ts

@@ -0,0 +1,7 @@
+import type { ActionBuilder } from "../types";
+type ActionOptions = {
+    description?: string;
+};
+export declare function defineAction<const TId extends string>(id: TId, options?: ActionOptions): ActionBuilder<TId>;
+export {};
+//# sourceMappingURL=define-action.d.ts.map

package/dist/actions/builders/define-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-action.d.ts","sourceRoot":"","sources":["../../../src/actions/builders/define-action.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EAcd,MAAM,UAAU,CAAA;AAGjB,KAAK,aAAa,GAAG;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAgB,YAAY,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,EACnD,EAAE,EAAE,GAAG,EACP,OAAO,CAAC,EAAE,aAAa,GACtB,aAAa,CAAC,GAAG,CAAC,CAIpB"}

package/dist/actions/builders/params.d.ts

@@ -0,0 +1,23 @@
+import type { SchemaOrRef } from "../../ontology";
+import type { QuantitativeTypeId } from "../../ontology/units";
+import type { ActionParamConfig } from "../types";
+type ActionParamOptions = {
+    description?: string;
+    semanticType?: QuantitativeTypeId;
+    nullable?: boolean;
+};
+type FieldFromOptions<TOptions, TKey extends string, TFallback> = TOptions extends Record<TKey, infer TValue> ? {
+    [K in TKey]: TValue;
+} : {
+    [K in TKey]?: TFallback;
+};
+type ActionParamResult<TSchema extends SchemaOrRef, TRequired extends boolean, TOptions extends ActionParamOptions | undefined> = {
+    schema: TSchema;
+    required: TRequired;
+} & FieldFromOptions<TOptions, "description", string> & FieldFromOptions<TOptions, "semanticType", QuantitativeTypeId> & FieldFromOptions<TOptions, "nullable", boolean>;
+export declare function param<const TSchema extends SchemaOrRef, const TOptions extends ActionParamOptions | undefined = undefined>(schema: TSchema, options?: TOptions): ActionParamResult<TSchema, true, TOptions>;
+export declare function optional<const TParam extends ActionParamConfig>(paramConfig: TParam): Omit<TParam, "required"> & {
+    readonly required: false;
+};
+export {};
+//# sourceMappingURL=params.d.ts.map

package/dist/actions/builders/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../../src/actions/builders/params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,gBAAgB,CAAC,QAAQ,EAAE,IAAI,SAAS,MAAM,EAAE,SAAS,IAC5D,QAAQ,SAAS,MAAM,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC,GACvC;KAAG,CAAC,IAAI,IAAI,GAAG,MAAM;CAAE,GACvB;KAAG,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,SAAS;CAAE,CAAA;AAEjC,KAAK,iBAAiB,CACpB,OAAO,SAAS,WAAW,EAC3B,SAAS,SAAS,OAAO,EACzB,QAAQ,SAAS,kBAAkB,GAAG,SAAS,IAC7C;IACF,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,SAAS,CAAA;CACpB,GAAG,gBAAgB,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,CAAC,GACnD,gBAAgB,CAAC,QAAQ,EAAE,cAAc,EAAE,kBAAkB,CAAC,GAC9D,gBAAgB,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAA;AAEjD,wBAAgB,KAAK,CACnB,KAAK,CAAC,OAAO,SAAS,WAAW,EACjC,KAAK,CAAC,QAAQ,SAAS,kBAAkB,GAAG,SAAS,GAAG,SAAS,EACjE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,iBAAiB,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,CASjF;AAED,wBAAgB,QAAQ,CAAC,KAAK,CAAC,MAAM,SAAS,iBAAiB,EAC7D,WAAW,EAAE,MAAM,GAClB,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAA;CAAE,CAKzD"}

package/dist/actions/builders.d.ts

@@ -0,0 +1,3 @@
+export { defineAction } from "./builders/define-action";
+export { optional, param } from "./builders/params";
+//# sourceMappingURL=builders.d.ts.map

package/dist/actions/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../src/actions/builders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/actions/commit-edits.d.ts

@@ -0,0 +1,54 @@
+import type { EditBatch } from "../edits";
+import type { EventActor } from "../events/envelope";
+import type { EffectiveLinkChange, EffectiveObjectChange, ExpectedLinkRevision, ExpectedLinkScopeRevision, ExpectedObjectRevision, OntologyOperationOutcome } from "../materializer";
+import type { OntologyMutationRuntime } from "../runtime/ontology-mutations";
+import type { Storage } from "../storage/types";
+/** Exact reads an Action handler depended on, protected by row-level CAS at commit time. */
+export interface ActionReadDependencies {
+    readonly objects: readonly ExpectedObjectRevision[];
+    readonly links: readonly ExpectedLinkRevision[];
+    readonly linkScopes: readonly ExpectedLinkScopeRevision[];
+}
+export interface CommitActionEditsInput {
+    readonly mutations: Pick<OntologyMutationRuntime, "commitEdits">;
+    readonly projectId: string;
+    readonly runId: string;
+    readonly actionId: string;
+    readonly batch: EditBatch;
+    readonly dependencies?: ActionReadDependencies;
+    readonly actor?: EventActor;
+}
+/** The authoritative ontology commit an Action run produced. */
+export interface ActionEditCommitResult {
+    readonly commitId: string;
+    readonly created: boolean;
+    readonly eventCount: number;
+    readonly outcomes: readonly OntologyOperationOutcome[];
+    readonly changes: {
+        readonly objects: readonly EffectiveObjectChange[];
+        readonly links: readonly EffectiveLinkChange[];
+    };
+    readonly committedAt: Date;
+}
+export interface FindActionEditCommitInput {
+    readonly storage: Pick<Storage, "ontology">;
+    readonly projectId: string;
+    readonly runId: string;
+}
+/**
+ * Commits one Action run's recorded edits as a single atomic ontology commit.
+ *
+ * The batch lowers to canonical Materializer operations and the Materializer validates the Action run
+ * identity, applies managed authority, resolves effective state, writes the authoritative commit, and
+ * inserts outbox facts in one transaction. Repeating the call for the same run replays that commit;
+ * a divergent request for the same run is a typed idempotency conflict.
+ */
+export declare function commitActionEdits(input: CommitActionEditsInput): Promise<ActionEditCommitResult>;
+/**
+ * Resolves the authoritative commit an Action run already produced, if any.
+ *
+ * Resume uses the exact `{ actionRunId }` origin instead of rerunning handlers, so a redelivered run
+ * returns the persisted result without recomputing an idempotency hash.
+ */
+export declare function findActionEditCommit(input: FindActionEditCommitInput): Promise<ActionEditCommitResult | null>;
+//# sourceMappingURL=commit-edits.d.ts.map

package/dist/actions/commit-edits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-edits.d.ts","sourceRoot":"","sources":["../../src/actions/commit-edits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,EAEV,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACzB,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG/C,4FAA4F;AAC5F,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,SAAS,sBAAsB,EAAE,CAAA;IACnD,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAC/C,QAAQ,CAAC,UAAU,EAAE,SAAS,yBAAyB,EAAE,CAAA;CAC1D;AAID,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,uBAAuB,EAAE,aAAa,CAAC,CAAA;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,YAAY,CAAC,EAAE,sBAAsB,CAAA;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAA;CAC5B;AAED,gEAAgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,CAAA;IACtD,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAA;QAClD,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAA;KAC/C,CAAA;IACD,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAA;CAC3B;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,sBAAsB,CAAC,CAYjC;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,yBAAyB,GAC/B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAYxC"}

package/dist/actions/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class ActionDefinitionError extends Error {
+    readonly name = "ActionDefinitionError";
+}
+export declare class ActionEditCommitError extends Error {
+    readonly name = "ActionEditCommitError";
+}
+export declare function missingActionMutationMessage(actionId: string): string;
+export declare function effectsWithoutEditsMessage(actionId: string): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/actions/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/actions/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,2BAA0B;CACxC;AAED,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,2BAA0B;CACxC;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/dist/actions/index.d.ts

@@ -0,0 +1,14 @@
+export { defineAction, optional, param } from "./builders";
+export type { ActionEditCommitResult, ActionReadDependencies, CommitActionEditsInput, FindActionEditCommitInput, } from "./commit-edits";
+export { commitActionEdits, findActionEditCommit } from "./commit-edits";
+export { ActionDefinitionError, ActionEditCommitError } from "./errors";
+export type { ActionReadFacadeOptions, ActionReadObjectSetSource } from "./read-facade";
+export { ActionReadRecorder, createActionReadFacade } from "./read-facade";
+export { ActionRegistry } from "./registry";
+export type { RequestActionAndWaitInput, RequestActionAndWaitOptions, RequestActionInput, RequestActionOptions, RequestActionResult, WaitForActionRunInput, } from "./request";
+export { requestAction, requestActionAndWait, waitForActionRun } from "./request";
+export { ActionsRuntime } from "./runtime";
+export type { ActionBinding, ActionBlobContext, ActionBuilder, ActionDefinition, ActionEditsContext, ActionEditsHandler, ActionEffectsContext, ActionEffectsHandler, ActionObjectSubject, ActionParamConfig, ActionParamsConfig, ActionPhaseCommit, ActionReadFacade, ActionReadObjectByIdHandle, ActionReadObjectSet, ActionRunPhaseInfo, ActionRuntimeFacade, ActionSubject, ActionTargetObject, ActionTelemetryObjectSet, ActionValidationContext, ActionValidator, ActionWritebackContext, ActionWritebackHandler, ActionWritebackValue, GlobalActionAfterEditsBuilder, GlobalActionAfterWritebackBuilder, GlobalActionDefinition, GlobalActionEditsContext, GlobalActionEditsHandler, GlobalActionEffectsContext, GlobalActionEffectsHandler, GlobalActionParamsBuilder, GlobalActionPhaseBuilder, GlobalActionValidationContext, GlobalActionValidator, GlobalActionWritebackContext, GlobalActionWritebackHandler, InferActionParams, ObjectActionAfterEditsBuilder, ObjectActionAfterWritebackBuilder, ObjectActionDefinition, ObjectActionParamsBuilder, ObjectActionPhaseBuilder, } from "./types";
+export { coerceActionParamsToTyped, isActionDefinition, isGlobalActionDefinition, isObjectActionDefinition, } from "./validation";
+export { runActionValidators } from "./validators";
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC1D,YAAY,EACV,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AACxE,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AACvE,YAAY,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAA;AACvF,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3C,YAAY,EACV,yBAAyB,EACzB,2BAA2B,EAC3B,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,0BAA0B,EAC1B,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,wBAAwB,EACxB,uBAAuB,EACvB,eAAe,EACf,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,EACpB,6BAA6B,EAC7B,iCAAiC,EACjC,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,6BAA6B,EAC7B,qBAAqB,EACrB,4BAA4B,EAC5B,4BAA4B,EAC5B,iBAAiB,EACjB,6BAA6B,EAC7B,iCAAiC,EACjC,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA"}