@sixb/core 0.0.1

package/dist/chunk-t358gywy.js

@@ -0,0 +1,991 @@
+// @bun
+import {
+  getOntologyMutationRuntime,
+  shareOntologyMutationRuntime
+} from "./chunk-v5c085yp.js";
+import {
+  countObjects,
+  executeObjectQuery,
+  existsObjects,
+  explainObjectQuery,
+  facetObjects,
+  validateObjectQuery
+} from "./chunk-2gpr6jsz.js";
+import {
+  createObjectQueryBuilder
+} from "./chunk-gqdd7508.js";
+import {
+  ObjectQueryPlanningError
+} from "./chunk-88ppkr54.js";
+import {
+  RuntimeError
+} from "./chunk-k6j72mtt.js";
+import {
+  requestAction,
+  requestActionAndWait
+} from "./chunk-jdwx7vzs.js";
+import {
+  normalizeJsonProperties
+} from "./chunk-yvef9xwc.js";
+import {
+  ObjectNotFoundError
+} from "./chunk-aebzcsxr.js";
+import {
+  linkRefKey,
+  telemetryPointKey
+} from "./chunk-p6r5g77m.js";
+import {
+  MaterializationObjectNotFoundError
+} from "./chunk-ry24jbr1.js";
+import {
+  shareSixbErrorReporter
+} from "./chunk-t72dvahb.js";
+import {
+  assertKnownProperties,
+  assertLinkTargetType,
+  assertLinkTokenBelongsToObjectType,
+  assertPropertyTokenBelongsToObjectType,
+  assertTelemetryProperty,
+  normalizeLinkProperties,
+  normalizeObjectProperties,
+  validateLinkProperties,
+  validateObjectProperties
+} from "./chunk-tsk2bxs3.js";
+import {
+  OntologyNotFoundError,
+  OntologyValidationError
+} from "./chunk-dktq02ne.js";
+import {
+  assertAuthorized,
+  assertCanAppendTelemetry,
+  assertCanEdit,
+  assertPrivileged
+} from "./chunk-0fygrz37.js";
+import {
+  stableJsonStringify
+} from "./chunk-1vffvydj.js";
+import {
+  __export
+} from "./chunk-y64skrwp.js";
+// src/objects/action/request.ts
+async function requestAction2(ctx, params) {
+  return requestAction(ctx, {
+    actionId: params.actionId,
+    subject: {
+      kind: "object",
+      objectTypeId: ctx.objectType.id,
+      primaryId: params.primaryId
+    },
+    params: params.params,
+    runId: params.options?.runId,
+    signal: params.options?.signal
+  });
+}
+async function requestActionAndWait2(ctx, params) {
+  return requestActionAndWait(ctx, {
+    actionId: params.actionId,
+    subject: {
+      kind: "object",
+      objectTypeId: ctx.objectType.id,
+      primaryId: params.primaryId
+    },
+    params: params.params,
+    runId: params.options?.runId,
+    timeoutMs: params.options?.timeoutMs,
+    signal: params.options?.signal,
+    onRequested: params.options?.onRequested
+  });
+}
+// src/objects/context/resolve.ts
+function requireLinkDefinition(objectType, linkId) {
+  const def = objectType.links.find((l) => l.id === linkId);
+  if (!def)
+    throw new OntologyNotFoundError(`Unknown link '${objectType.id}.${linkId}'`);
+  return def;
+}
+function resolveObjectContext(runtime, objectTypeId) {
+  const objectType = runtime.ontology.resolveObjectType(objectTypeId);
+  const primaryPropertyId = runtime.ontology.getPrimaryPropertyId(objectTypeId);
+  return { ...runtime, objectType, primaryPropertyId };
+}
+function resolveLinkContext(objCtx, linkId) {
+  const linkDefinition = requireLinkDefinition(objCtx.objectType, linkId);
+  return { ...objCtx, linkDefinition };
+}
+// src/objects/errors.ts
+class ObjectError extends Error {
+  name = "ObjectError";
+}
+// src/objects/materializer-adapter.ts
+import { randomUUID } from "crypto";
+function runtimeActor(ctx) {
+  const principal = ctx.authorization?.principal;
+  return principal === undefined ? {} : { actor: principal };
+}
+async function commitRuntimeOperations(ctx, operations) {
+  const mutations = getOntologyMutationRuntime(ctx);
+  const commit = await mutations.commitEdits({
+    mode: "atomic",
+    source: { kind: "runtime", requestId: randomUUID() },
+    ...runtimeActor(ctx),
+    operations,
+    expectedObjects: [],
+    expectedLinks: [],
+    expectedLinkScopes: []
+  });
+  return commit;
+}
+async function commitRuntimeBatch(ctx, groups) {
+  const operations = groups.flatMap((group) => group.operations);
+  if (operations.length === 0) {
+    return { commit: null, outcomes: new Map };
+  }
+  const operationGroups = groups.filter((group) => group.operations.length > 1).map((group) => group.operations.map((operation) => operation.id));
+  const mutations = getOntologyMutationRuntime(ctx);
+  const commit = await mutations.commitEdits({
+    mode: "continue",
+    source: { kind: "runtime", requestId: randomUUID() },
+    ...runtimeActor(ctx),
+    operations,
+    ...operationGroups.length > 0 ? { operationGroups } : {}
+  });
+  const byId = new Map(commit.outcomes.map((outcome) => [outcome.id, outcome]));
+  const outcomes = new Map;
+  for (const group of groups) {
+    outcomes.set(group.index, group.operations.map((operation) => requireOutcome(byId, operation.id)));
+  }
+  return { commit, outcomes };
+}
+function runtimeOperationId(index, subOrdinal = 0) {
+  return subOrdinal === 0 ? `op:${index}` : `op:${index}.${subOrdinal}`;
+}
+function normalizeRuntimeObject(input) {
+  const { objectType, primaryPropertyId, properties, valueTypesById } = input;
+  assertKnownProperties(objectType, properties);
+  validateObjectProperties(objectType, properties, valueTypesById);
+  const primaryValue = properties[primaryPropertyId];
+  if (primaryValue === undefined || primaryValue === null) {
+    throw new OntologyValidationError(`[Sixb] Missing primary property '${primaryPropertyId}' in upsert for '${objectType.id}'`);
+  }
+  const normalized = normalizeObjectProperties(objectType.properties, properties, valueTypesById, objectType.id);
+  const { [primaryPropertyId]: _identity, ...managed } = normalized;
+  return {
+    primaryId: String(primaryValue),
+    properties: normalizeJsonProperties(managed, `${objectType.id} properties`)
+  };
+}
+function normalizeRuntimeLink(input) {
+  const { objectType, linkDefinition, linkId, targetTypeId, properties, valueTypesById } = input;
+  assertLinkTargetType(objectType.id, linkId, linkDefinition, targetTypeId, input.isValidLinkTarget);
+  validateLinkProperties(objectType, linkDefinition, properties, undefined, valueTypesById);
+  const normalized = normalizeLinkProperties(objectType, linkDefinition, properties, valueTypesById);
+  if (normalized === undefined)
+    return;
+  return normalizeJsonProperties(normalized, `${objectType.id}.${linkId} properties`);
+}
+function objectUpsertOperation(input) {
+  return { id: input.id, kind: "object.upsert", ref: input.ref, properties: input.properties };
+}
+function objectDeleteOperation(input) {
+  return { id: input.id, kind: "object.delete", ref: input.ref };
+}
+function objectRestoreOperation(input) {
+  return { id: input.id, kind: "object.restore", ref: input.ref };
+}
+function linkUpsertOperation(input) {
+  return {
+    id: input.id,
+    kind: "link.upsert",
+    ref: input.ref,
+    ...input.properties !== undefined ? { properties: input.properties } : {}
+  };
+}
+function linkDeleteOperation(input) {
+  return { id: input.id, kind: "link.delete", ref: input.ref };
+}
+function requireItemOutcomes(commit, index) {
+  const outcomes = commit.outcomes.get(index);
+  if (!outcomes || outcomes.length === 0) {
+    throw new ObjectError(`[Sixb] Materializer returned no outcome for batch item ${index}.`);
+  }
+  return outcomes;
+}
+function requireEffectiveObject(outcome) {
+  if (!outcome.ok || !outcome.object) {
+    throw new ObjectError(`[Sixb] Materializer returned no effective object for '${outcome.id}'.`);
+  }
+  return outcome.object;
+}
+function toObjectRow(projectId, snapshot) {
+  return {
+    projectId,
+    objectTypeId: snapshot.ref.objectTypeId,
+    primaryId: snapshot.ref.primaryId,
+    properties: structuredClone(snapshot.properties),
+    createdAt: new Date(snapshot.createdAt),
+    updatedAt: new Date(snapshot.updatedAt),
+    version: snapshot.version,
+    lastCommitId: snapshot.lastCommitId
+  };
+}
+function toItemError(error) {
+  switch (error.code) {
+    case "validation":
+      return new OntologyValidationError(error.message);
+  }
+}
+function requireOutcome(outcomes, id) {
+  const outcome = outcomes.get(id);
+  if (!outcome) {
+    throw new ObjectError(`[Sixb] Materializer returned no outcome for '${id}'.`);
+  }
+  return outcome;
+}
+
+// src/objects/link/authorization.ts
+function assertCanWriteLink(ctx, endpoints) {
+  assertCanEdit(ctx, endpoints.sourceTypeId);
+  assertAuthorized(ctx, { kind: "object.view", objectTypeId: endpoints.targetTypeId });
+}
+
+// src/objects/link/remove.ts
+async function removeLink(ctx, params) {
+  const { objectType, linkDefinition, ontology } = ctx;
+  const { sourceId, linkId, targetTypeId, targetId } = params;
+  assertCanWriteLink(ctx, { sourceTypeId: objectType.id, targetTypeId });
+  assertLinkTargetType(objectType.id, linkId, linkDefinition, targetTypeId, (expected, actual) => ontology.isValidLinkTarget(expected, actual));
+  await commitRuntimeOperations(ctx, [
+    linkDeleteOperation({
+      id: runtimeOperationId(0),
+      ref: {
+        source: { objectTypeId: objectType.id, primaryId: sourceId },
+        linkId,
+        target: { objectTypeId: targetTypeId, primaryId: targetId }
+      }
+    })
+  ]);
+}
+// src/objects/link/endpoints.ts
+function collectEndpointLookups(items) {
+  const lookups = [];
+  const seen = new Set;
+  for (const item of items) {
+    for (const endpoint of [
+      { objectTypeId: item.objectType.id, primaryId: item.sourceId },
+      { objectTypeId: item.targetTypeId, primaryId: item.targetId }
+    ]) {
+      const key = endpointKey(endpoint.objectTypeId, endpoint.primaryId);
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      lookups.push(endpoint);
+    }
+  }
+  return lookups;
+}
+async function loadEndpointExistence(ctx, lookups) {
+  if (lookups.length === 0)
+    return new Set;
+  const rows = await ctx.storage.objects.getByPrimaryIdBatch({
+    projectId: ctx.projectId,
+    items: lookups
+  });
+  return new Set(rows.keys());
+}
+function requireEndpoints(item, existing) {
+  if (!existing.has(endpointKey(item.objectType.id, item.sourceId))) {
+    throw new ObjectNotFoundError(item.objectType.id, item.sourceId, "Source object not found");
+  }
+  if (!existing.has(endpointKey(item.targetTypeId, item.targetId))) {
+    throw new ObjectNotFoundError(item.targetTypeId, item.targetId, "Target object not found");
+  }
+}
+function endpointKey(objectTypeId, primaryId) {
+  return `${objectTypeId}:${primaryId}`;
+}
+
+// src/objects/link/upsert.ts
+async function upsertLink(ctx, params) {
+  const { objectType, linkDefinition, ontology } = ctx;
+  const { sourceId, linkId, targetTypeId, targetId, properties } = params;
+  assertCanWriteLink(ctx, { sourceTypeId: objectType.id, targetTypeId });
+  const endpoints = { objectType, sourceId, targetTypeId, targetId };
+  requireEndpoints(endpoints, await loadEndpointExistence(ctx, collectEndpointLookups([endpoints])));
+  const normalizedProperties = normalizeRuntimeLink({
+    objectType,
+    linkDefinition,
+    linkId,
+    targetTypeId,
+    properties,
+    valueTypesById: ontology.getValueTypesById(),
+    isValidLinkTarget: (expected, actual) => ontology.isValidLinkTarget(expected, actual)
+  });
+  await commitRuntimeOperations(ctx, [
+    linkUpsertOperation({
+      id: runtimeOperationId(0),
+      ref: {
+        source: { objectTypeId: objectType.id, primaryId: sourceId },
+        linkId,
+        target: { objectTypeId: targetTypeId, primaryId: targetId }
+      },
+      ...normalizedProperties !== undefined ? { properties: normalizedProperties } : {}
+    })
+  ]);
+}
+// src/objects/runtime-batch.ts
+async function runRuntimeItemBatch(batch) {
+  const { items } = batch;
+  if (items.length === 0)
+    return [];
+  const results = new Array(items.length);
+  const planned = [];
+  const claims = new Map;
+  const aliases = new Map;
+  for (const [index, item] of items.entries()) {
+    let plan;
+    try {
+      plan = batch.plan(item, index);
+    } catch (error) {
+      results[index] = {
+        ok: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+      continue;
+    }
+    const claimed = claims.get(plan.key);
+    if (claimed) {
+      if (claimed.fingerprint !== plan.fingerprint) {
+        results[index] = {
+          ok: false,
+          error: new OntologyValidationError(`[Sixb] Conflicting duplicate ${plan.label} at batch positions ${claimed.index} and ${index}`)
+        };
+        continue;
+      }
+      aliases.set(index, claimed.index);
+      continue;
+    }
+    claims.set(plan.key, { index, fingerprint: plan.fingerprint });
+    planned.push({ index, operations: plan.operations });
+  }
+  const commit = await commitRuntimeBatch(batch.ctx, planned);
+  for (const { index } of planned) {
+    const outcomes = requireItemOutcomes(commit, index);
+    const failed = outcomes.find((outcome) => !outcome.ok);
+    results[index] = failed?.ok === false ? { ok: false, error: toItemError(failed.error) } : { ok: true, value: batch.value(outcomes) };
+  }
+  for (const [index, source] of aliases) {
+    results[index] = results[source];
+  }
+  return results;
+}
+
+// src/objects/link/upsert-batch.ts
+async function upsertLinkBatch(ctx, items) {
+  const { ontology } = ctx;
+  if (items.length === 0)
+    return [];
+  for (const item of items) {
+    assertCanWriteLink(ctx, {
+      sourceTypeId: item.objectType.id,
+      targetTypeId: item.targetTypeId
+    });
+  }
+  const existing = await loadEndpointExistence(ctx, collectEndpointLookups(items));
+  const valueTypesById = ontology.getValueTypesById();
+  return runRuntimeItemBatch({
+    ctx,
+    items,
+    plan(item, index) {
+      requireEndpoints(item, existing);
+      const properties = normalizeRuntimeLink({
+        objectType: item.objectType,
+        linkDefinition: item.linkDefinition,
+        linkId: item.linkId,
+        targetTypeId: item.targetTypeId,
+        properties: item.properties,
+        valueTypesById,
+        isValidLinkTarget: (expected, actual) => ontology.isValidLinkTarget(expected, actual)
+      });
+      const ref = {
+        source: { objectTypeId: item.objectType.id, primaryId: item.sourceId },
+        linkId: item.linkId,
+        target: { objectTypeId: item.targetTypeId, primaryId: item.targetId }
+      };
+      const edge = linkRefKey(ref);
+      return {
+        key: edge,
+        label: `link '${item.objectType.id}:${item.sourceId}.${item.linkId} -> ${item.targetTypeId}:${item.targetId}'`,
+        fingerprint: stableJsonStringify(properties ?? null),
+        operations: [
+          linkUpsertOperation({
+            id: runtimeOperationId(index),
+            ref,
+            ...properties !== undefined ? { properties } : {}
+          })
+        ]
+      };
+    },
+    value: () => {
+      return;
+    }
+  });
+}
+// src/objects/object/delete.ts
+async function deleteObject(ctx, primaryId) {
+  assertCanEdit(ctx, ctx.objectType.id);
+  await commitRuntimeOperations(ctx, [
+    objectDeleteOperation({
+      id: runtimeOperationId(0),
+      ref: { objectTypeId: ctx.objectType.id, primaryId }
+    })
+  ]);
+}
+async function restoreObject(ctx, primaryId) {
+  assertCanEdit(ctx, ctx.objectType.id);
+  await commitRuntimeOperations(ctx, [
+    objectRestoreOperation({
+      id: runtimeOperationId(0),
+      ref: { objectTypeId: ctx.objectType.id, primaryId }
+    })
+  ]);
+}
+// src/objects/object/upsert.ts
+async function upsertObject(ctx, properties) {
+  assertCanEdit(ctx, ctx.objectType.id);
+  const { objectType, primaryPropertyId, ontology } = ctx;
+  const normalized = normalizeRuntimeObject({
+    objectType,
+    primaryPropertyId,
+    properties,
+    valueTypesById: ontology.getValueTypesById()
+  });
+  const ref = { objectTypeId: objectType.id, primaryId: normalized.primaryId };
+  const commit = await commitRuntimeOperations(ctx, [
+    objectUpsertOperation({ id: runtimeOperationId(0), ref, properties: normalized.properties })
+  ]);
+  return toObjectRow(ctx.projectId, requireEffectiveObject(commit.outcomes[0]));
+}
+// src/objects/object/upsert-batch.ts
+async function upsertObjectBatch(ctx, items) {
+  assertCanEdit(ctx, ctx.objectType.id);
+  const { objectType, primaryPropertyId, ontology } = ctx;
+  const valueTypesById = ontology.getValueTypesById();
+  return runRuntimeItemBatch({
+    ctx,
+    items,
+    plan(item, index) {
+      const normalized = normalizeRuntimeObject({
+        objectType,
+        primaryPropertyId,
+        properties: item.properties,
+        valueTypesById
+      });
+      const ref = { objectTypeId: objectType.id, primaryId: normalized.primaryId };
+      return {
+        key: `${ref.objectTypeId}:${ref.primaryId}`,
+        label: `object '${ref.objectTypeId}:${ref.primaryId}'`,
+        fingerprint: stableJsonStringify(normalized.properties),
+        operations: [
+          objectUpsertOperation({
+            id: runtimeOperationId(index),
+            ref,
+            properties: normalized.properties
+          })
+        ]
+      };
+    },
+    value: ([outcome]) => toObjectRow(ctx.projectId, requireEffectiveObject(outcome))
+  });
+}
+// src/objects/telemetry/write-batch.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function writeTelemetryBatch(ctx, points) {
+  for (const objectTypeId of new Set(points.map((point) => point.series.object.objectTypeId))) {
+    assertCanAppendTelemetry(ctx, objectTypeId);
+  }
+  if (points.length === 0)
+    return null;
+  let commit;
+  try {
+    commit = await getOntologyMutationRuntime(ctx).appendTelemetry({
+      source: { kind: "runtime", requestId: randomUUID2() },
+      ...ctx.authorization === undefined ? {} : { actor: ctx.authorization.principal },
+      points
+    });
+  } catch (error) {
+    if (error instanceof MaterializationObjectNotFoundError) {
+      throw new ObjectNotFoundError(error.objectTypeId, error.primaryId, "Object not found for telemetry append");
+    }
+    throw error;
+  }
+  return commit;
+}
+
+// src/objects/telemetry/append-batch.ts
+function isUnitBearingValue(raw) {
+  if (raw === null || typeof raw !== "object") {
+    return false;
+  }
+  const record = raw;
+  return "value" in record && typeof record.unit === "string" && Object.keys(record).length === 2;
+}
+async function appendTelemetryBatch(ctx, items) {
+  assertCanAppendTelemetry(ctx, ctx.objectType.id);
+  const { objectType } = ctx;
+  const points = new Map;
+  for (const item of items) {
+    const at = (item.at ?? new Date).toISOString();
+    for (const [propertyId, rawValue] of Object.entries(item.properties)) {
+      const propertyToken = objectType.p[propertyId];
+      if (!propertyToken) {
+        throw new OntologyValidationError(`Unknown property '${objectType.id}.${propertyId}'`);
+      }
+      assertTelemetryProperty(propertyToken.property);
+      const series = {
+        object: { objectTypeId: objectType.id, primaryId: item.id },
+        propertyId: propertyToken.id
+      };
+      points.set(telemetryPointKey(series, at), {
+        series,
+        value: isUnitBearingValue(rawValue) ? rawValue.value : rawValue,
+        ...isUnitBearingValue(rawValue) ? { unit: rawValue.unit } : {},
+        at
+      });
+    }
+  }
+  await writeTelemetryBatch(ctx, [...points.values()]);
+}
+// src/objects/telemetry/history.ts
+async function getTelemetryHistoryBatch(input, options) {
+  assertTelemetrySeriesViewable(input.series, options.authorization);
+  return options.storage.getHistoryBatch(input);
+}
+function assertTelemetrySeriesViewable(series, authorization) {
+  for (const objectTypeId of new Set(series.map((entry) => entry.objectTypeId))) {
+    assertAuthorized({ authorization: authorization ?? undefined }, { kind: "object.view", objectTypeId });
+  }
+}
+// src/objects/sdk/telemetry-channel.ts
+function createTelemetryChannel(ctx, primaryId) {
+  return (property) => {
+    const { objectType } = ctx;
+    assertPropertyTokenBelongsToObjectType(objectType, property);
+    assertTelemetryProperty(property.property);
+    const series = { objectTypeId: objectType.id, objectId: primaryId, propertyId: property.id };
+    const channel = {
+      append: async (input) => {
+        await writeTelemetryBatch(ctx, [
+          {
+            series: {
+              object: { objectTypeId: objectType.id, primaryId },
+              propertyId: property.id
+            },
+            value: input.value,
+            ...input.unit !== undefined ? { unit: input.unit } : {},
+            at: input.at.toISOString()
+          }
+        ]);
+      },
+      history: async (input = {}) => {
+        const timeseries = ctx.storage.timeseries;
+        if (!timeseries) {
+          throw new RuntimeError("[Sixb] Reading telemetry requires storage.timeseries support.");
+        }
+        const [result] = await getTelemetryHistoryBatch({
+          projectId: ctx.projectId,
+          series: [series],
+          ...input.from !== undefined ? { from: input.from } : {},
+          ...input.to !== undefined ? { to: input.to } : {},
+          ...input.limit !== undefined ? { limitPerSeries: input.limit } : {},
+          ...input.order !== undefined ? { order: input.order } : {}
+        }, { storage: timeseries, authorization: ctx.authorization });
+        return (result?.points ?? []).map((point) => ({
+          value: point.value,
+          at: point.at,
+          ...point.unit !== undefined ? { unit: point.unit } : {}
+        }));
+      }
+    };
+    return channel;
+  };
+}
+
+// src/objects/sdk/object-handle.ts
+function createObjectByIdHandle(ctx, primaryId) {
+  const objectHandle = {
+    get: async () => {
+      assertAuthorized(ctx, { kind: "object.view", objectTypeId: ctx.objectType.id });
+      const row = await ctx.storage.objects.getByPrimaryId({
+        projectId: ctx.projectId,
+        objectTypeId: ctx.objectType.id,
+        primaryId
+      });
+      return row ? row : null;
+    },
+    listLinks: async (linkToken) => {
+      assertPrivileged(ctx, "listLinks");
+      if (linkToken) {
+        assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
+      }
+      return ctx.storage.objects.listLinks({
+        projectId: ctx.projectId,
+        objectTypeId: ctx.objectType.id,
+        objectId: primaryId,
+        linkId: linkToken?.id
+      });
+    },
+    link: async (linkToken, target, options) => {
+      assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
+      const linkCtx = { ...ctx, linkDefinition: linkToken.link };
+      await upsertLink(linkCtx, {
+        sourceId: primaryId,
+        linkId: linkToken.id,
+        targetTypeId: target.objectTypeId,
+        targetId: target.primaryId,
+        properties: options?.properties
+      });
+    },
+    unlink: async (linkToken, target) => {
+      assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
+      const linkCtx = { ...ctx, linkDefinition: linkToken.link };
+      await removeLink(linkCtx, {
+        sourceId: primaryId,
+        linkId: linkToken.id,
+        targetTypeId: target.objectTypeId,
+        targetId: target.primaryId
+      });
+    },
+    delete: async () => {
+      await deleteObject(ctx, primaryId);
+    },
+    restore: async () => {
+      await restoreObject(ctx, primaryId);
+    },
+    requestAction: async (input) => {
+      const actionId = input.action?.id ?? input.actionId;
+      if (!actionId) {
+        throw new OntologyValidationError("[Sixb] requestAction requires either 'action' or 'actionId'");
+      }
+      return requestAction2(ctx, {
+        primaryId,
+        actionId,
+        params: input.params,
+        options: { runId: input.runId }
+      });
+    },
+    requestActionAndWait: async (input) => {
+      const actionId = input.action?.id ?? input.actionId;
+      if (!actionId) {
+        throw new OntologyValidationError("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
+      }
+      return requestActionAndWait2(ctx, {
+        primaryId,
+        actionId,
+        params: input.params,
+        options: {
+          timeoutMs: input.timeoutMs,
+          signal: input.signal
+        }
+      });
+    },
+    telemetry: createTelemetryChannel(ctx, primaryId)
+  };
+  return objectHandle;
+}
+// src/objects/sdk/runtime-query-executor.ts
+function createRuntimeQueryExecutor(params) {
+  const { projectId, ontology, storage, authorization } = params;
+  const executorOptions = { ontology, storage: storage.objects, authorization };
+  return {
+    async list(query, options) {
+      try {
+        return await executeObjectQuery({ projectId, query, includeTotal: options?.includeTotal }, executorOptions);
+      } catch (error) {
+        if (error instanceof ObjectQueryPlanningError) {
+          throw addSdkPlanningHints(error);
+        }
+        throw error;
+      }
+    },
+    async count(query) {
+      const result = await countObjects({ projectId, query }, executorOptions);
+      return result.count;
+    },
+    async exists(query) {
+      const result = await existsObjects({ projectId, query }, executorOptions);
+      return result.exists;
+    },
+    async facets(query, facets) {
+      const result = await facetObjects({ projectId, query, facets }, executorOptions);
+      return result.facets.map((facet) => ({
+        propertyId: facet.propertyId,
+        buckets: [...facet.buckets]
+      }));
+    },
+    validate(query) {
+      return validateObjectQuery(query, { ontology, normalize: false });
+    },
+    explain(query) {
+      return explainObjectQuery(query, { ontology, normalize: false });
+    }
+  };
+}
+function addSdkPlanningHints(error) {
+  if (!error.issues.some((issue) => issue.code === "fallback_requires_bound"))
+    return error;
+  return new ObjectQueryPlanningError(error.issues.map((issue) => issue.code === "fallback_requires_bound" ? {
+    ...issue,
+    message: "Object query fallback requires an explicit result bound. Add .limit(n) or .page({ pageSize: n }) before .list()."
+  } : issue));
+}
+
+// src/objects/sdk/object-set.ts
+function createObjectSet(params) {
+  const { objectType } = params;
+  const primaryProp = objectType.properties.find((p) => p.primary);
+  if (!primaryProp) {
+    throw new OntologyValidationError(`Object type '${objectType.id}' has no primary property`);
+  }
+  const primaryPropertyId = primaryProp.id;
+  const {
+    projectId,
+    ontology,
+    actionRegistry,
+    events,
+    lakeStorage,
+    blobStorage,
+    storage,
+    queues,
+    authorization
+  } = params;
+  const queryExecutor = createRuntimeQueryExecutor({ projectId, ontology, storage, authorization });
+  const resolvedCtx = {
+    projectId,
+    ontology,
+    actionRegistry,
+    events,
+    lakeStorage,
+    blobStorage,
+    storage,
+    queues,
+    authorization,
+    objectType,
+    primaryPropertyId
+  };
+  shareOntologyMutationRuntime(params, resolvedCtx);
+  shareSixbErrorReporter(params, resolvedCtx);
+  const objectSet = {
+    get: async (id) => {
+      assertAuthorized(resolvedCtx, { kind: "object.view", objectTypeId: objectType.id });
+      const row = await storage.objects.getByPrimaryId({
+        projectId,
+        objectTypeId: objectType.id,
+        primaryId: id
+      });
+      return row ? row : null;
+    },
+    upsert: async (input) => {
+      const row = await upsertObject(resolvedCtx, input.properties);
+      return row;
+    },
+    query: () => createObjectQueryBuilder({
+      query: { kind: "start", objectTypeId: objectType.id },
+      executor: queryExecutor
+    }),
+    byId: (id) => createObjectByIdHandle(resolvedCtx, id),
+    list: async (input) => {
+      assertAuthorized(resolvedCtx, { kind: "object.view", objectTypeId: objectType.id });
+      const result = await storage.objects.list({
+        projectId,
+        objectTypeId: objectType.id,
+        primaryIdPrefix: input?.idPrefix,
+        primaryIdSuffix: input?.idSuffix,
+        updatedAfter: input?.updatedAfter,
+        updatedBefore: input?.updatedBefore,
+        createdAfter: input?.createdAfter,
+        createdBefore: input?.createdBefore,
+        limit: input?.limit,
+        offset: input?.offset,
+        orderBy: input?.orderBy,
+        order: input?.order
+      });
+      return {
+        objects: result.objects.map((row) => row),
+        hasMore: result.hasMore,
+        total: result.total ?? result.objects.length
+      };
+    },
+    appendTelemetryBatch: async (items) => {
+      await appendTelemetryBatch(resolvedCtx, items);
+    },
+    requestAction: async (input) => {
+      const actionId = input.action?.id ?? input.actionId;
+      if (!actionId) {
+        throw new OntologyValidationError("[Sixb] requestAction requires either 'action' or 'actionId'");
+      }
+      return requestAction2(resolvedCtx, {
+        primaryId: input.id,
+        actionId,
+        params: input.params,
+        options: { runId: input.runId }
+      });
+    },
+    requestActionAndWait: async (input) => {
+      const actionId = input.action?.id ?? input.actionId;
+      if (!actionId) {
+        throw new OntologyValidationError("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
+      }
+      return requestActionAndWait2(resolvedCtx, {
+        primaryId: input.id,
+        actionId,
+        params: input.params,
+        options: {
+          timeoutMs: input.timeoutMs,
+          signal: input.signal
+        }
+      });
+    },
+    upsertLink: async (input) => {
+      const linkDefinition = requireLinkDefinition(objectType, input.linkId);
+      const linkCtx = { ...resolvedCtx, linkDefinition };
+      await upsertLink(linkCtx, {
+        sourceId: input.sourceId,
+        linkId: input.linkId,
+        targetTypeId: input.targetTypeId,
+        targetId: input.targetId,
+        properties: input.properties
+      });
+    },
+    removeLink: async (input) => {
+      const linkDefinition = requireLinkDefinition(objectType, input.linkId);
+      const linkCtx = { ...resolvedCtx, linkDefinition };
+      await removeLink(linkCtx, {
+        sourceId: input.sourceId,
+        linkId: input.linkId,
+        targetTypeId: input.targetTypeId,
+        targetId: input.targetId
+      });
+    }
+  };
+  return objectSet;
+}
+// src/objects/service/index.ts
+var exports_service = {};
+__export(exports_service, {
+  upsertObjectBatch: () => upsertObjectBatch2,
+  upsertObject: () => upsertObject2,
+  upsertLinkBatch: () => upsertLinkBatch2,
+  upsertLink: () => upsertLink2,
+  requestActionAndWait: () => requestActionAndWait3,
+  requestAction: () => requestAction3,
+  removeLink: () => removeLink2,
+  listObjects: () => listObjects,
+  appendTelemetry: () => appendTelemetry
+});
+
+// src/objects/service/action-service.ts
+async function requestAction3(runtime, objectTypeId, primaryId, actionId, params, options) {
+  const ctx = resolveObjectContext(runtime, objectTypeId);
+  return requestAction2(ctx, { primaryId, actionId, params, options });
+}
+async function requestActionAndWait3(runtime, objectTypeId, primaryId, actionId, params, options) {
+  const ctx = resolveObjectContext(runtime, objectTypeId);
+  return requestActionAndWait2(ctx, { primaryId, actionId, params, options });
+}
+// src/objects/service/link-service.ts
+async function upsertLink2(runtime, objectTypeId, sourceId, linkId, target) {
+  const ctx = resolveObjectContext(runtime, objectTypeId);
+  const linkCtx = resolveLinkContext(ctx, linkId);
+  await upsertLink(linkCtx, {
+    sourceId,
+    linkId,
+    targetTypeId: target.targetTypeId,
+    targetId: target.targetId,
+    properties: target.properties
+  });
+}
+async function upsertLinkBatch2(runtime, items) {
+  const resolvedItems = items.map((item) => {
+    const objectType = runtime.ontology.resolveObjectType(item.objectTypeId);
+    const linkDefinition = requireLinkDefinition(objectType, item.linkId);
+    return {
+      objectType,
+      linkDefinition,
+      sourceId: item.sourceId,
+      linkId: item.linkId,
+      targetTypeId: item.target.targetTypeId,
+      targetId: item.target.targetId,
+      properties: item.target.properties
+    };
+  });
+  return upsertLinkBatch(runtime, resolvedItems);
+}
+async function removeLink2(runtime, objectTypeId, sourceId, linkId, target) {
+  const ctx = resolveObjectContext(runtime, objectTypeId);
+  const linkCtx = resolveLinkContext(ctx, linkId);
+  await removeLink(linkCtx, {
+    sourceId,
+    linkId,
+    targetTypeId: target.targetTypeId,
+    targetId: target.targetId
+  });
+}
+// src/objects/service/list-service.ts
+async function listObjects(runtime, params) {
+  const objectTypeIds = resolveAuthorizedTypeFilter(runtime, params.objectTypeIds);
+  if (runtime.authorization && objectTypeIds !== undefined && objectTypeIds.length === 0) {
+    return { objects: [], hasMore: false, total: 0 };
+  }
+  const result = await runtime.storage.objects.list({
+    projectId: runtime.projectId,
+    objectTypeId: objectTypeIds?.length === 1 ? objectTypeIds[0] : objectTypeIds,
+    primaryIdPrefix: params.idPrefix,
+    primaryIdSuffix: params.idSuffix,
+    updatedAfter: params.updatedAfter,
+    updatedBefore: params.updatedBefore,
+    createdAfter: params.createdAfter,
+    createdBefore: params.createdBefore,
+    limit: params.limit,
+    offset: params.offset,
+    orderBy: params.orderBy,
+    order: params.order
+  });
+  return {
+    objects: [...result.objects],
+    hasMore: result.hasMore,
+    total: result.total
+  };
+}
+function resolveAuthorizedTypeFilter(runtime, requested) {
+  if (requested) {
+    for (const objectTypeId of requested) {
+      runtime.ontology.resolveObjectType(objectTypeId);
+    }
+  }
+  const expanded = requested ? [...new Set(requested.flatMap((id) => [id, ...runtime.ontology.listSubTypes(id)]))] : undefined;
+  if (!runtime.authorization) {
+    return expanded;
+  }
+  if (!expanded) {
+    return [...runtime.authorization.grants["view:object"]];
+  }
+  for (const objectTypeId of expanded) {
+    assertAuthorized(runtime, { kind: "object.view", objectTypeId });
+  }
+  return expanded;
+}
+// src/objects/service/object-service.ts
+async function upsertObject2(runtime, objectTypeId, properties) {
+  return upsertObject(resolveObjectContext(runtime, objectTypeId), properties);
+}
+async function upsertObjectBatch2(runtime, objectTypeId, items) {
+  return upsertObjectBatch(resolveObjectContext(runtime, objectTypeId), items);
+}
+// src/objects/service/telemetry-service.ts
+async function appendTelemetry(runtime, objectTypeId, items) {
+  const ctx = resolveObjectContext(runtime, objectTypeId);
+  await appendTelemetryBatch(ctx, items);
+}
+export { requestAction2 as requestAction, requireLinkDefinition, resolveObjectContext, resolveLinkContext, ObjectError, removeLink, upsertLink, upsertLinkBatch, deleteObject, restoreObject, upsertObject, upsertObjectBatch, writeTelemetryBatch, appendTelemetryBatch, getTelemetryHistoryBatch, createObjectSet, exports_service };
+
+//# debugId=95B324667271C7FB64756E2164756E21