@sixb/core 0.1.8 → 0.1.10

package/dist/{chunk-aa2pen2v.js → chunk-976rxdpx.js}

@@ -1,78 +1,91 @@
 // @bun
 import {
-  getOntologyMutationRuntime,
-  shareOntologyMutationRuntime
-} from "./chunk-xhy826cz.js";
+  resolveRuntimeAuthorizationForProject,
+  assertAuthorized2,
+  assertCanEdit2,
+  assertCanAppendTelemetry2
+} from "./chunk-dz5h08xv.js";
 import {
-  createObjectQueryBuilder
-} from "./chunk-4rh2m6zg.js";
+  createSixbError2
+} from "./chunk-f4w3yp4f.js";
 import {
-  assertAuthorizedObjectReaderBinding,
-  getAuthorizedOntologyView,
-  requestAction,
-  requestActionAndWait
-} from "./chunk-h5vqbfmd.js";
+  normalizeObjectProperties2,
+  assertPropertyTokenBelongsToObjectType2,
+  assertLinkTokenBelongsToObjectType2,
+  assertKnownProperties2,
+  validateObjectProperties2,
+  assertLinkTargetType2,
+  normalizeLinkProperties2,
+  validateLinkProperties2,
+  assertTelemetryProperty2
+} from "./chunk-ms2tmn1k.js";
 import {
-  explainObjectQuery,
-  validateObjectQuery
-} from "./chunk-q0k9nc5a.js";
+  RuntimeError2
+} from "./chunk-e0d1rzef.js";
 import {
-  ObjectQueryPlanningError
-} from "./chunk-rte5sm3z.js";
+  ObjectNotFoundError2
+} from "./chunk-8vj0rjgs.js";
 import {
-  normalizeJsonProperties
-} from "./chunk-f26bck4t.js";
+  objectBatchKey2
+} from "./chunk-p6a4npdx.js";
 import {
-  ObjectNotFoundError,
-  objectBatchKey
-} from "./chunk-sbzzr4kx.js";
+  linkRefKey2,
+  telemetryPointKey2
+} from "./chunk-c5rkjrgp.js";
 import {
-  linkRefKey,
-  telemetryPointKey
-} from "./chunk-dbc80ad7.js";
+  validateObjectQuery2,
+  explainObjectQuery2
+} from "./chunk-g7knyczr.js";
 import {
-  MaterializationObjectNotFoundError
-} from "./chunk-ry24jbr1.js";
+  assertAuthorizedObjectReaderBinding,
+  getAuthorizedOntologyView,
+  requestAction3,
+  requestActionAndWait2
+} from "./chunk-nmbxcaqx.js";
 import {
-  RuntimeError
-} from "./chunk-p2vqaxkc.js";
+  shareSixbErrorReporter2
+} from "./chunk-7apz6hg4.js";
 import {
-  shareSixbErrorReporter
-} from "./chunk-jq43kdvk.js";
+  normalizeJsonProperties2
+} from "./chunk-ftv470j8.js";
 import {
-  assertAuthorized,
-  assertCanAppendTelemetry,
-  assertCanEdit,
-  resolveRuntimeAuthorizationForProject
-} from "./chunk-p1x242ad.js";
+  getOntologyMutationRuntime2,
+  shareOntologyMutationRuntime2
+} from "./chunk-85cd7e8c.js";
 import {
-  assertKnownProperties,
-  assertLinkTargetType,
-  assertLinkTokenBelongsToObjectType,
-  assertPropertyTokenBelongsToObjectType,
-  assertTelemetryProperty,
-  normalizeLinkProperties,
-  normalizeObjectProperties,
-  validateLinkProperties,
-  validateObjectProperties
-} from "./chunk-h0k55pc7.js";
+  createObjectQueryBuilder2
+} from "./chunk-rb1xx120.js";
 import {
-  OntologyNotFoundError,
-  OntologyValidationError
-} from "./chunk-dktq02ne.js";
+  ObjectQueryPlanningError2
+} from "./chunk-5hz0fnca.js";
 import {
-  createSixbError
-} from "./chunk-2xns679x.js";
+  MaterializationObjectNotFoundError2
+} from "./chunk-yv79ncbv.js";
 import {
-  stableJsonStringify
-} from "./chunk-n6jxh8sw.js";
+  OntologyValidationError2,
+  OntologyNotFoundError2
+} from "./chunk-cqr3acm1.js";
 import {
-  __export
-} from "./chunk-y64skrwp.js";
+  stableJsonStringify2
+} from "./chunk-wy0qdqfm.js";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 
 // src/objects/action/request.ts
 async function requestAction2(ctx, params) {
-  return requestAction(ctx, ctx.execution, {
+  return requestAction3(ctx, ctx.execution, {
     actionId: params.actionId,
     subject: {
       kind: "object",
@@ -84,8 +97,8 @@ async function requestAction2(ctx, params) {
     signal: params.options?.signal
   });
 }
-async function requestActionAndWait2(ctx, params) {
-  return requestActionAndWait(ctx, ctx.execution, {
+async function requestActionAndWait(ctx, params) {
+  return requestActionAndWait2(ctx, ctx.execution, {
     actionId: params.actionId,
     subject: {
       kind: "object",
@@ -100,14 +113,14 @@ async function requestActionAndWait2(ctx, params) {
   });
 }
 // src/objects/errors.ts
-class ObjectError extends Error {
+class ObjectError2 extends Error {
   name = "ObjectError";
 }
 
 // src/objects/materializer-adapter.ts
 import { randomUUID } from "crypto";
 async function commitRuntimeOperations(ctx, operations) {
-  const mutations = getOntologyMutationRuntime(ctx);
+  const mutations = getOntologyMutationRuntime2(ctx);
   const commit = await mutations.commitEdits({
     mode: "atomic",
     source: { kind: "runtime", requestId: randomUUID() },
@@ -124,7 +137,7 @@ async function commitRuntimeBatch(ctx, groups) {
     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 mutations = getOntologyMutationRuntime2(ctx);
   const commit = await mutations.commitEdits({
     mode: "continue",
     source: { kind: "runtime", requestId: randomUUID() },
@@ -143,27 +156,27 @@ function runtimeOperationId(index, subOrdinal = 0) {
 }
 function normalizeRuntimeObject(input) {
   const { objectType, primaryPropertyId, properties, valueTypesById } = input;
-  assertKnownProperties(objectType, properties);
-  validateObjectProperties(objectType, properties, valueTypesById);
+  assertKnownProperties2(objectType, properties);
+  validateObjectProperties2(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}'`);
+    throw new OntologyValidationError2(`[Sixb] Missing primary property '${primaryPropertyId}' in upsert for '${objectType.id}'`);
   }
-  const normalized = normalizeObjectProperties(objectType.properties, properties, valueTypesById, objectType.id);
+  const normalized = normalizeObjectProperties2(objectType.properties, properties, valueTypesById, objectType.id);
   const { [primaryPropertyId]: _identity, ...managed } = normalized;
   return {
     primaryId: String(primaryValue),
-    properties: normalizeJsonProperties(managed, `${objectType.id} properties`)
+    properties: normalizeJsonProperties2(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);
+  assertLinkTargetType2(objectType.id, linkId, linkDefinition, targetTypeId, input.isValidLinkTarget);
+  validateLinkProperties2(objectType, linkDefinition, properties, undefined, valueTypesById);
+  const normalized = normalizeLinkProperties2(objectType, linkDefinition, properties, valueTypesById);
   if (normalized === undefined)
     return;
-  return normalizeJsonProperties(normalized, `${objectType.id}.${linkId} properties`);
+  return normalizeJsonProperties2(normalized, `${objectType.id}.${linkId} properties`);
 }
 function objectUpsertOperation(input) {
   return { id: input.id, kind: "object.upsert", ref: input.ref, properties: input.properties };
@@ -188,13 +201,13 @@ function linkDeleteOperation(input) {
 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}.`);
+    throw new ObjectError2(`[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}'.`);
+    throw new ObjectError2(`[Sixb] Materializer returned no effective object for '${outcome.id}'.`);
   }
   return outcome.object;
 }
@@ -213,29 +226,29 @@ function toObjectRow(projectId, snapshot) {
 function toItemError(error) {
   switch (error.code) {
     case "validation":
-      return new OntologyValidationError(error.message);
+      return new OntologyValidationError2(error.message);
   }
 }
 function requireOutcome(outcomes, id) {
   const outcome = outcomes.get(id);
   if (!outcome) {
-    throw new ObjectError(`[Sixb] Materializer returned no outcome for '${id}'.`);
+    throw new ObjectError2(`[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 });
+  assertCanEdit2(ctx, endpoints.sourceTypeId);
+  assertAuthorized2(ctx, { kind: "object.view", objectTypeId: endpoints.targetTypeId });
 }
 
 // src/objects/link/remove.ts
-async function removeLink(ctx, params) {
+async function removeLink2(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));
+  assertLinkTargetType2(objectType.id, linkId, linkDefinition, targetTypeId, (expected, actual) => ontology.isValidLinkTarget(expected, actual));
   await commitRuntimeOperations(ctx, [
     linkDeleteOperation({
       id: runtimeOperationId(0),
@@ -277,18 +290,18 @@ async function loadEndpointExistence(ctx, lookups) {
 }
 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");
+    throw new ObjectNotFoundError2(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");
+    throw new ObjectNotFoundError2(item.targetTypeId, item.targetId, "Target object not found");
   }
 }
 function endpointKey(objectTypeId, primaryId) {
-  return objectBatchKey(objectTypeId, primaryId);
+  return objectBatchKey2(objectTypeId, primaryId);
 }
 
 // src/objects/link/upsert.ts
-async function upsertLink(ctx, params) {
+async function upsertLink2(ctx, params) {
   const { objectType, linkDefinition, ontology } = ctx;
   const { sourceId, linkId, targetTypeId, targetId, properties } = params;
   assertCanWriteLink(ctx, { sourceTypeId: objectType.id, targetTypeId });
@@ -341,7 +354,7 @@ async function runRuntimeItemBatch(batch) {
       if (claimed.fingerprint !== plan.fingerprint) {
         results[index] = {
           ok: false,
-          error: new OntologyValidationError(`[Sixb] Conflicting duplicate ${plan.label} at batch positions ${claimed.index} and ${index}`)
+          error: new OntologyValidationError2(`[Sixb] Conflicting duplicate ${plan.label} at batch positions ${claimed.index} and ${index}`)
         };
         continue;
       }
@@ -364,7 +377,7 @@ async function runRuntimeItemBatch(batch) {
 }
 
 // src/objects/link/upsert-batch.ts
-async function upsertLinkBatch(ctx, items) {
+async function upsertLinkBatch2(ctx, items) {
   const { ontology } = ctx;
   if (items.length === 0)
     return [];
@@ -395,11 +408,11 @@ async function upsertLinkBatch(ctx, items) {
         linkId: item.linkId,
         target: { objectTypeId: item.targetTypeId, primaryId: item.targetId }
       };
-      const edge = linkRefKey(ref);
+      const edge = linkRefKey2(ref);
       return {
         key: edge,
         label: `link '${item.objectType.id}:${item.sourceId}.${item.linkId} -> ${item.targetTypeId}:${item.targetId}'`,
-        fingerprint: stableJsonStringify(properties ?? null),
+        fingerprint: stableJsonStringify2(properties ?? null),
         operations: [
           linkUpsertOperation({
             id: runtimeOperationId(index),
@@ -415,8 +428,8 @@ async function upsertLinkBatch(ctx, items) {
   });
 }
 // src/objects/object/delete.ts
-async function deleteObject(ctx, primaryId) {
-  assertCanEdit(ctx, ctx.objectType.id);
+async function deleteObject2(ctx, primaryId) {
+  assertCanEdit2(ctx, ctx.objectType.id);
   await commitRuntimeOperations(ctx, [
     objectDeleteOperation({
       id: runtimeOperationId(0),
@@ -424,8 +437,8 @@ async function deleteObject(ctx, primaryId) {
     })
   ]);
 }
-async function restoreObject(ctx, primaryId) {
-  assertCanEdit(ctx, ctx.objectType.id);
+async function restoreObject2(ctx, primaryId) {
+  assertCanEdit2(ctx, ctx.objectType.id);
   await commitRuntimeOperations(ctx, [
     objectRestoreOperation({
       id: runtimeOperationId(0),
@@ -435,8 +448,8 @@ async function restoreObject(ctx, primaryId) {
 }
 
 // src/objects/object/upsert.ts
-async function upsertObject(ctx, properties) {
-  assertCanEdit(ctx, ctx.objectType.id);
+async function upsertObject2(ctx, properties) {
+  assertCanEdit2(ctx, ctx.objectType.id);
   const { objectType, primaryPropertyId, ontology } = ctx;
   const normalized = normalizeRuntimeObject({
     objectType,
@@ -452,8 +465,8 @@ async function upsertObject(ctx, properties) {
 }
 
 // src/objects/object/upsert-batch.ts
-async function upsertObjectBatch(ctx, items) {
-  assertCanEdit(ctx, ctx.objectType.id);
+async function upsertObjectBatch2(ctx, items) {
+  assertCanEdit2(ctx, ctx.objectType.id);
   const { objectType, primaryPropertyId, ontology } = ctx;
   const valueTypesById = ontology.getValueTypesById();
   return runRuntimeItemBatch({
@@ -470,7 +483,7 @@ async function upsertObjectBatch(ctx, items) {
       return {
         key: `${ref.objectTypeId}:${ref.primaryId}`,
         label: `object '${ref.objectTypeId}:${ref.primaryId}'`,
-        fingerprint: stableJsonStringify(normalized.properties),
+        fingerprint: stableJsonStringify2(normalized.properties),
         operations: [
           objectUpsertOperation({
             id: runtimeOperationId(index),
@@ -485,21 +498,21 @@ async function upsertObjectBatch(ctx, items) {
 }
 // src/objects/telemetry/write-batch.ts
 import { randomUUID as randomUUID2 } from "crypto";
-async function writeTelemetryBatch(ctx, points) {
+async function writeTelemetryBatch2(ctx, points) {
   for (const objectTypeId of new Set(points.map((point) => point.series.object.objectTypeId))) {
-    assertCanAppendTelemetry(ctx, objectTypeId);
+    assertCanAppendTelemetry2(ctx, objectTypeId);
   }
   if (points.length === 0)
     return null;
   let commit;
   try {
-    commit = await getOntologyMutationRuntime(ctx).appendTelemetry({
+    commit = await getOntologyMutationRuntime2(ctx).appendTelemetry({
       source: { kind: "runtime", requestId: randomUUID2() },
       points
     });
   } catch (error) {
-    if (error instanceof MaterializationObjectNotFoundError) {
-      throw new ObjectNotFoundError(error.objectTypeId, error.primaryId, "Object not found for telemetry append");
+    if (error instanceof MaterializationObjectNotFoundError2) {
+      throw new ObjectNotFoundError2(error.objectTypeId, error.primaryId, "Object not found for telemetry append");
     }
     throw error;
   }
@@ -514,8 +527,8 @@ function isUnitBearingValue(raw) {
   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);
+async function appendTelemetryBatch2(ctx, items) {
+  assertCanAppendTelemetry2(ctx, ctx.objectType.id);
   const { objectType } = ctx;
   const points = new Map;
   for (const item of items) {
@@ -523,14 +536,14 @@ async function appendTelemetryBatch(ctx, items) {
     for (const [propertyId, rawValue] of Object.entries(item.properties)) {
       const propertyToken = objectType.p[propertyId];
       if (!propertyToken) {
-        throw new OntologyValidationError(`Unknown property '${objectType.id}.${propertyId}'`);
+        throw new OntologyValidationError2(`Unknown property '${objectType.id}.${propertyId}'`);
       }
-      assertTelemetryProperty(propertyToken.property);
+      assertTelemetryProperty2(propertyToken.property);
       const series = {
         object: { objectTypeId: objectType.id, primaryId: item.id },
         propertyId: propertyToken.id
       };
-      points.set(telemetryPointKey(series, at), {
+      points.set(telemetryPointKey2(series, at), {
         series,
         value: isUnitBearingValue(rawValue) ? rawValue.value : rawValue,
         ...isUnitBearingValue(rawValue) ? { unit: rawValue.unit } : {},
@@ -538,11 +551,11 @@ async function appendTelemetryBatch(ctx, items) {
       });
     }
   }
-  await writeTelemetryBatch(ctx, [...points.values()]);
+  await writeTelemetryBatch2(ctx, [...points.values()]);
 }
 
 // src/objects/telemetry/history.ts
-async function getTelemetryHistoryBatch(input, options) {
+async function getTelemetryHistoryBatch2(input, options) {
   const objectReader = options.objectReader;
   const storage = options.storage;
   const projectId = objectReader.projectId;
@@ -729,7 +742,7 @@ function snapshotProviderPoint(point) {
   }
 }
 function invalidTimeseriesProviderResult(cause) {
-  return createSixbError("internal.unexpected", "[Sixb] Timeseries storage returned data outside the requested series.", cause === undefined ? {} : { cause });
+  return createSixbError2("internal.unexpected", "[Sixb] Timeseries storage returned data outside the requested series.", cause === undefined ? {} : { cause });
 }
 function isInvalidTimeseriesProviderResult(error) {
   return error instanceof Error && "code" in error && error.code === "internal.unexpected" && error.message === "[Sixb] Timeseries storage returned data outside the requested series.";
@@ -744,31 +757,31 @@ function seriesKey(series) {
   return JSON.stringify([series.objectTypeId, series.objectId, series.propertyId]);
 }
 // src/objects/context/resolve.ts
-function requireLinkDefinition(objectType, linkId) {
+function requireLinkDefinition2(objectType, linkId) {
   const def = objectType.links.find((l) => l.id === linkId);
   if (!def)
-    throw new OntologyNotFoundError(`Unknown link '${objectType.id}.${linkId}'`);
+    throw new OntologyNotFoundError2(`Unknown link '${objectType.id}.${linkId}'`);
   return def;
 }
-function resolveObjectContext(runtime, objectTypeId) {
+function resolveObjectContext2(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);
+function resolveLinkContext2(objCtx, linkId) {
+  const linkDefinition = requireLinkDefinition2(objCtx.objectType, linkId);
   return { ...objCtx, linkDefinition };
 }
 // src/objects/sdk/telemetry-channel.ts
 function createTelemetryChannel(ctx, primaryId) {
   return (property) => {
     const { objectType } = ctx;
-    assertPropertyTokenBelongsToObjectType(objectType, property);
-    assertTelemetryProperty(property.property);
+    assertPropertyTokenBelongsToObjectType2(objectType, property);
+    assertTelemetryProperty2(property.property);
     const series = { objectTypeId: objectType.id, objectId: primaryId, propertyId: property.id };
     const channel = {
       append: async (input) => {
-        await writeTelemetryBatch(ctx, [
+        await writeTelemetryBatch2(ctx, [
           {
             series: {
               object: { objectTypeId: objectType.id, primaryId },
@@ -784,13 +797,13 @@ function createTelemetryChannel(ctx, primaryId) {
         const timeseries = ctx.storage.timeseries;
         const objectReader = ctx.objectReader;
         if (!timeseries) {
-          throw new RuntimeError("[Sixb] Reading telemetry requires storage.timeseries support.");
+          throw new RuntimeError2("[Sixb] Reading telemetry requires storage.timeseries support.");
         }
         const from = input.from;
         const to = input.to;
         const limit = input.limit;
         const order = input.order;
-        const [result] = await getTelemetryHistoryBatch({
+        const [result] = await getTelemetryHistoryBatch2({
           series: [series],
           ...from !== undefined ? { from } : {},
           ...to !== undefined ? { to } : {},
@@ -823,7 +836,7 @@ function createObjectByIdHandle(ctx, primaryId) {
     },
     listLinks: async (linkToken) => {
       if (linkToken) {
-        assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
+        assertLinkTokenBelongsToObjectType2(ctx.objectType, linkToken);
       }
       return ctx.objectReader.listLinks({
         objectTypeId: ctx.objectType.id,
@@ -832,9 +845,9 @@ function createObjectByIdHandle(ctx, primaryId) {
       });
     },
     link: async (linkToken, target, options) => {
-      assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
+      assertLinkTokenBelongsToObjectType2(ctx.objectType, linkToken);
       const linkCtx = { ...ctx, linkDefinition: linkToken.link };
-      await upsertLink(linkCtx, {
+      await upsertLink2(linkCtx, {
         sourceId: primaryId,
         linkId: linkToken.id,
         targetTypeId: target.objectTypeId,
@@ -843,9 +856,9 @@ function createObjectByIdHandle(ctx, primaryId) {
       });
     },
     unlink: async (linkToken, target) => {
-      assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
+      assertLinkTokenBelongsToObjectType2(ctx.objectType, linkToken);
       const linkCtx = { ...ctx, linkDefinition: linkToken.link };
-      await removeLink(linkCtx, {
+      await removeLink2(linkCtx, {
         sourceId: primaryId,
         linkId: linkToken.id,
         targetTypeId: target.objectTypeId,
@@ -853,15 +866,15 @@ function createObjectByIdHandle(ctx, primaryId) {
       });
     },
     delete: async () => {
-      await deleteObject(ctx, primaryId);
+      await deleteObject2(ctx, primaryId);
     },
     restore: async () => {
-      await restoreObject(ctx, primaryId);
+      await restoreObject2(ctx, primaryId);
     },
     requestAction: async (input) => {
       const actionId = input.action?.id ?? input.actionId;
       if (!actionId) {
-        throw new OntologyValidationError("[Sixb] requestAction requires either 'action' or 'actionId'");
+        throw new OntologyValidationError2("[Sixb] requestAction requires either 'action' or 'actionId'");
       }
       return requestAction2(ctx, {
         primaryId,
@@ -873,9 +886,9 @@ function createObjectByIdHandle(ctx, primaryId) {
     requestActionAndWait: async (input) => {
       const actionId = input.action?.id ?? input.actionId;
       if (!actionId) {
-        throw new OntologyValidationError("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
+        throw new OntologyValidationError2("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
       }
-      return requestActionAndWait2(ctx, {
+      return requestActionAndWait(ctx, {
         primaryId,
         actionId,
         params: input.params,
@@ -898,7 +911,7 @@ function createRuntimeQueryExecutor(params) {
       try {
         return await objectReader.executeQuery({ query, includeTotal: options?.includeTotal });
       } catch (error) {
-        if (error instanceof ObjectQueryPlanningError) {
+        if (error instanceof ObjectQueryPlanningError2) {
           throw addSdkPlanningHints(error);
         }
         throw error;
@@ -920,24 +933,24 @@ function createRuntimeQueryExecutor(params) {
       }));
     },
     validate(query) {
-      return validateObjectQuery(query, { ontology, normalize: false });
+      return validateObjectQuery2(query, { ontology, normalize: false });
     },
     explain(query) {
-      return explainObjectQuery(query, { ontology, normalize: false });
+      return explainObjectQuery2(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" ? {
+  return new ObjectQueryPlanningError2(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) {
+function createObjectSet2(params) {
   assertAuthorizedObjectReaderBinding({
     reader: params.objectReader,
     scope: { execution: params.execution, authorization: params.runtimeAuthorization }
@@ -945,7 +958,7 @@ 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`);
+    throw new OntologyValidationError2(`Object type '${objectType.id}' has no primary property`);
   }
   const primaryPropertyId = primaryProp.id;
   const {
@@ -980,8 +993,8 @@ function createObjectSet(params) {
     objectType,
     primaryPropertyId
   };
-  shareOntologyMutationRuntime(params, resolvedCtx);
-  shareSixbErrorReporter(params, resolvedCtx);
+  shareOntologyMutationRuntime2(params, resolvedCtx);
+  shareSixbErrorReporter2(params, resolvedCtx);
   const objectSet = {
     get: async (id) => {
       const row = await objectReader.getByPrimaryId({
@@ -991,10 +1004,10 @@ function createObjectSet(params) {
       return row ? row : null;
     },
     upsert: async (input) => {
-      const row = await upsertObject(resolvedCtx, input.properties);
+      const row = await upsertObject2(resolvedCtx, input.properties);
       return row;
     },
-    query: () => createObjectQueryBuilder({
+    query: () => createObjectQueryBuilder2({
       query: { kind: "start", objectTypeId: objectType.id },
       executor: queryExecutor
     }),
@@ -1020,12 +1033,12 @@ function createObjectSet(params) {
       };
     },
     appendTelemetryBatch: async (items) => {
-      await appendTelemetryBatch(resolvedCtx, items);
+      await appendTelemetryBatch2(resolvedCtx, items);
     },
     requestAction: async (input) => {
       const actionId = input.action?.id ?? input.actionId;
       if (!actionId) {
-        throw new OntologyValidationError("[Sixb] requestAction requires either 'action' or 'actionId'");
+        throw new OntologyValidationError2("[Sixb] requestAction requires either 'action' or 'actionId'");
       }
       return requestAction2(resolvedCtx, {
         primaryId: input.id,
@@ -1037,9 +1050,9 @@ function createObjectSet(params) {
     requestActionAndWait: async (input) => {
       const actionId = input.action?.id ?? input.actionId;
       if (!actionId) {
-        throw new OntologyValidationError("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
+        throw new OntologyValidationError2("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
       }
-      return requestActionAndWait2(resolvedCtx, {
+      return requestActionAndWait(resolvedCtx, {
         primaryId: input.id,
         actionId,
         params: input.params,
@@ -1050,9 +1063,9 @@ function createObjectSet(params) {
       });
     },
     upsertLink: async (input) => {
-      const linkDefinition = requireLinkDefinition(objectType, input.linkId);
+      const linkDefinition = requireLinkDefinition2(objectType, input.linkId);
       const linkCtx = { ...resolvedCtx, linkDefinition };
-      await upsertLink(linkCtx, {
+      await upsertLink2(linkCtx, {
         sourceId: input.sourceId,
         linkId: input.linkId,
         targetTypeId: input.targetTypeId,
@@ -1061,9 +1074,9 @@ function createObjectSet(params) {
       });
     },
     removeLink: async (input) => {
-      const linkDefinition = requireLinkDefinition(objectType, input.linkId);
+      const linkDefinition = requireLinkDefinition2(objectType, input.linkId);
       const linkCtx = { ...resolvedCtx, linkDefinition };
-      await removeLink(linkCtx, {
+      await removeLink2(linkCtx, {
         sourceId: input.sourceId,
         linkId: input.linkId,
         targetTypeId: input.targetTypeId,
@@ -1076,31 +1089,31 @@ function createObjectSet(params) {
 // 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,
+  appendTelemetry: () => appendTelemetry,
   listObjects: () => listObjects,
-  appendTelemetry: () => appendTelemetry
+  removeLink: () => removeLink3,
+  requestAction: () => requestAction,
+  requestActionAndWait: () => requestActionAndWait3,
+  upsertLink: () => upsertLink3,
+  upsertLinkBatch: () => upsertLinkBatch3,
+  upsertObject: () => upsertObject3,
+  upsertObjectBatch: () => upsertObjectBatch3
 });
 
 // src/objects/service/action-service.ts
-async function requestAction3(runtime, execution, objectTypeId, primaryId, actionId, params, options) {
-  const ctx = { ...resolveObjectContext(runtime, objectTypeId), execution };
+async function requestAction(runtime, execution, objectTypeId, primaryId, actionId, params, options) {
+  const ctx = { ...resolveObjectContext2(runtime, objectTypeId), execution };
   return requestAction2(ctx, { primaryId, actionId, params, options });
 }
 async function requestActionAndWait3(runtime, execution, objectTypeId, primaryId, actionId, params, options) {
-  const ctx = { ...resolveObjectContext(runtime, objectTypeId), execution };
-  return requestActionAndWait2(ctx, { primaryId, actionId, params, options });
+  const ctx = { ...resolveObjectContext2(runtime, objectTypeId), execution };
+  return requestActionAndWait(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, {
+async function upsertLink3(runtime, objectTypeId, sourceId, linkId, target) {
+  const ctx = resolveObjectContext2(runtime, objectTypeId);
+  const linkCtx = resolveLinkContext2(ctx, linkId);
+  await upsertLink2(linkCtx, {
     sourceId,
     linkId,
     targetTypeId: target.targetTypeId,
@@ -1108,10 +1121,10 @@ async function upsertLink2(runtime, objectTypeId, sourceId, linkId, target) {
     properties: target.properties
   });
 }
-async function upsertLinkBatch2(runtime, items) {
+async function upsertLinkBatch3(runtime, items) {
   const resolvedItems = items.map((item) => {
     const objectType = runtime.ontology.resolveObjectType(item.objectTypeId);
-    const linkDefinition = requireLinkDefinition(objectType, item.linkId);
+    const linkDefinition = requireLinkDefinition2(objectType, item.linkId);
     return {
       objectType,
       linkDefinition,
@@ -1122,12 +1135,12 @@ async function upsertLinkBatch2(runtime, items) {
       properties: item.target.properties
     };
   });
-  return upsertLinkBatch(runtime, resolvedItems);
+  return upsertLinkBatch2(runtime, resolvedItems);
 }
-async function removeLink2(runtime, objectTypeId, sourceId, linkId, target) {
-  const ctx = resolveObjectContext(runtime, objectTypeId);
-  const linkCtx = resolveLinkContext(ctx, linkId);
-  await removeLink(linkCtx, {
+async function removeLink3(runtime, objectTypeId, sourceId, linkId, target) {
+  const ctx = resolveObjectContext2(runtime, objectTypeId);
+  const linkCtx = resolveLinkContext2(ctx, linkId);
+  await removeLink2(linkCtx, {
     sourceId,
     linkId,
     targetTypeId: target.targetTypeId,
@@ -1169,17 +1182,17 @@ function resolveTypeFilter(runtime, requested) {
   return requested ? [...new Set(requested.flatMap((id) => [id, ...ontology.listSubTypes(id)]))] : undefined;
 }
 // src/objects/service/object-service.ts
-async function upsertObject2(runtime, objectTypeId, properties) {
-  return upsertObject(resolveObjectContext(runtime, objectTypeId), properties);
+async function upsertObject3(runtime, objectTypeId, properties) {
+  return upsertObject2(resolveObjectContext2(runtime, objectTypeId), properties);
 }
-async function upsertObjectBatch2(runtime, objectTypeId, items) {
-  return upsertObjectBatch(resolveObjectContext(runtime, objectTypeId), items);
+async function upsertObjectBatch3(runtime, objectTypeId, items) {
+  return upsertObjectBatch2(resolveObjectContext2(runtime, objectTypeId), items);
 }
 // src/objects/service/telemetry-service.ts
 async function appendTelemetry(runtime, objectTypeId, items) {
-  const ctx = resolveObjectContext(runtime, objectTypeId);
-  await appendTelemetryBatch(ctx, items);
+  const ctx = resolveObjectContext2(runtime, objectTypeId);
+  await appendTelemetryBatch2(ctx, items);
 }
-export { requestAction2 as requestAction, ObjectError, removeLink, upsertLink, upsertLinkBatch, deleteObject, restoreObject, upsertObject, upsertObjectBatch, writeTelemetryBatch, appendTelemetryBatch, getTelemetryHistoryBatch, getLatestTelemetryPoint, requireLinkDefinition, resolveObjectContext, resolveLinkContext, createObjectSet, upsertLink2 as upsertLink1, upsertLinkBatch2 as upsertLinkBatch1, removeLink2 as removeLink1, listObjects, upsertObject2 as upsertObject1, upsertObjectBatch2 as upsertObjectBatch1, appendTelemetry, exports_service };
+export { requestAction2, ObjectError2, removeLink2, upsertLink2, upsertLinkBatch2, deleteObject2, restoreObject2, upsertObject2, upsertObjectBatch2, writeTelemetryBatch2, appendTelemetryBatch2, getTelemetryHistoryBatch2, getLatestTelemetryPoint, requireLinkDefinition2, resolveObjectContext2, resolveLinkContext2, createObjectSet2, upsertLink3, upsertLinkBatch3, removeLink3, listObjects, upsertObject3, upsertObjectBatch3, appendTelemetry, exports_service };
 
-//# debugId=33637F3A5FA7C13764756E2164756E21
+//# debugId=0ED9DE016D18A46464756E2164756E21