@sixb/core 0.1.7 → 0.1.9

package/dist/{chunk-e4rvtvpw.js → chunk-1enhpacz.js}

@@ -1,77 +1,91 @@
 // @bun
 import {
-  createObjectQueryBuilder
-} from "./chunk-4rh2m6zg.js";
+  resolveRuntimeAuthorizationForProject,
+  assertAuthorized2,
+  assertCanEdit2,
+  assertCanAppendTelemetry2
+} from "./chunk-dz5h08xv.js";
 import {
-  getOntologyMutationRuntime,
-  shareOntologyMutationRuntime
-} from "./chunk-xhy826cz.js";
+  createSixbError2
+} from "./chunk-f4w3yp4f.js";
 import {
-  countObjects,
-  executeObjectQuery,
-  existsObjects,
-  explainObjectQuery,
-  facetObjects,
-  validateObjectQuery
-} from "./chunk-3fqt22c4.js";
+  normalizeObjectProperties2,
+  assertPropertyTokenBelongsToObjectType2,
+  assertLinkTokenBelongsToObjectType2,
+  assertKnownProperties2,
+  validateObjectProperties2,
+  assertLinkTargetType2,
+  normalizeLinkProperties2,
+  validateLinkProperties2,
+  assertTelemetryProperty2
+} from "./chunk-ms2tmn1k.js";
 import {
-  ObjectQueryPlanningError
-} from "./chunk-rte5sm3z.js";
+  RuntimeError2
+} from "./chunk-e0d1rzef.js";
 import {
-  requestAction,
-  requestActionAndWait
-} from "./chunk-y35ma3mj.js";
+  ObjectNotFoundError2
+} from "./chunk-8vj0rjgs.js";
 import {
-  normalizeJsonProperties
-} from "./chunk-9aehf39w.js";
+  objectBatchKey2
+} from "./chunk-mjbk2djy.js";
 import {
-  ObjectNotFoundError,
-  objectBatchKey
-} from "./chunk-6ed5bwnd.js";
+  linkRefKey2,
+  telemetryPointKey2
+} from "./chunk-c5rkjrgp.js";
 import {
-  linkRefKey,
-  telemetryPointKey
-} from "./chunk-dbc80ad7.js";
+  validateObjectQuery2,
+  explainObjectQuery2
+} from "./chunk-0w35wavj.js";
 import {
-  MaterializationObjectNotFoundError
-} from "./chunk-ry24jbr1.js";
+  assertAuthorizedObjectReaderBinding,
+  getAuthorizedOntologyView,
+  requestAction3,
+  requestActionAndWait2
+} from "./chunk-ypbtykv6.js";
 import {
-  RuntimeError
-} from "./chunk-p2vqaxkc.js";
+  shareSixbErrorReporter2
+} from "./chunk-7apz6hg4.js";
 import {
-  shareSixbErrorReporter
-} from "./chunk-jq43kdvk.js";
+  normalizeJsonProperties2
+} from "./chunk-an5tt9y0.js";
 import {
-  assertAuthorized,
-  assertCanAppendTelemetry,
-  assertCanEdit,
-  assertPrivileged
-} from "./chunk-37wk412q.js";
+  getOntologyMutationRuntime2,
+  shareOntologyMutationRuntime2
+} from "./chunk-zcnq6105.js";
 import {
-  assertKnownProperties,
-  assertLinkTargetType,
-  assertLinkTokenBelongsToObjectType,
-  assertPropertyTokenBelongsToObjectType,
-  assertTelemetryProperty,
-  normalizeLinkProperties,
-  normalizeObjectProperties,
-  validateLinkProperties,
-  validateObjectProperties
-} from "./chunk-d63tybny.js";
+  createObjectQueryBuilder2
+} from "./chunk-rb1xx120.js";
 import {
-  OntologyNotFoundError,
-  OntologyValidationError
-} from "./chunk-dktq02ne.js";
+  ObjectQueryPlanningError2
+} from "./chunk-5hz0fnca.js";
 import {
-  stableJsonStringify
-} from "./chunk-n6jxh8sw.js";
+  MaterializationObjectNotFoundError2
+} from "./chunk-yv79ncbv.js";
 import {
-  __export
-} from "./chunk-y64skrwp.js";
+  OntologyValidationError2,
+  OntologyNotFoundError2
+} from "./chunk-cqr3acm1.js";
+import {
+  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",
@@ -83,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",
@@ -99,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() },
@@ -123,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() },
@@ -142,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 };
@@ -187,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;
 }
@@ -212,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),
@@ -276,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 });
@@ -340,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;
       }
@@ -363,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 [];
@@ -394,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),
@@ -414,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),
@@ -423,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),
@@ -434,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,
@@ -451,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({
@@ -469,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),
@@ -484,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;
   }
@@ -513,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) {
@@ -522,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 } : {},
@@ -537,48 +551,237 @@ 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) {
-  assertTelemetrySeriesViewable(input.series, options);
-  return options.storage.getHistoryBatch(input);
+async function getTelemetryHistoryBatch2(input, options) {
+  const objectReader = options.objectReader;
+  const storage = options.storage;
+  const projectId = objectReader.projectId;
+  const request = snapshotTelemetryHistoryInput(input, objectReader);
+  const uniqueSeries = deduplicateSeries(request.series);
+  const readableSeries = await selectReadableSeries(uniqueSeries, objectReader);
+  const resultsBySeries = await readAndValidateHistory({
+    storage,
+    projectId,
+    request,
+    series: readableSeries
+  });
+  const releasableSeries = readableSeries.length === 0 ? [] : await selectReadableSeries(readableSeries, objectReader);
+  const result = assembleHistoryResults({ request, resultsBySeries, releasableSeries });
+  objectReader.assertVisibleOutputWithinLimit(result);
+  return result;
+}
+async function getLatestTelemetryPoint(input, options) {
+  const objectReader = options.objectReader;
+  const storage = options.storage;
+  const projectId = objectReader.projectId;
+  const series = snapshotTelemetrySeries(input);
+  const readable = await objectReader.canReadObjectProperty(objectPropertySelection(series));
+  if (!readable)
+    return visibleLatestResult(null, objectReader);
+  const rawResult = await storage.getLatest({ projectId, ...series });
+  const result = rawResult === null ? null : snapshotProviderPoint(rawResult);
+  if (result)
+    assertTimeseriesPointMatchesSeries(projectId, series, result);
+  const releaseReadable = await objectReader.canReadObjectProperty(objectPropertySelection(series));
+  if (!releaseReadable)
+    return visibleLatestResult(null, objectReader);
+  return visibleLatestResult(result, objectReader);
+}
+function deduplicateSeries(series) {
+  const uniqueSeries = new Map;
+  for (const item of series) {
+    const key = seriesKey(item);
+    if (!uniqueSeries.has(key))
+      uniqueSeries.set(key, item);
+  }
+  return [...uniqueSeries.values()];
+}
+async function selectReadableSeries(series, objectReader) {
+  const readable = await objectReader.canReadObjectPropertiesBatch({
+    items: series.map(objectPropertySelection)
+  });
+  return series.filter((_, index) => readable[index] === true);
+}
+async function readAndValidateHistory(input) {
+  const { storage, projectId, request, series } = input;
+  const providerRequest = structuredClone({
+    projectId,
+    series,
+    ...request.from === undefined ? {} : { from: request.from },
+    ...request.to === undefined ? {} : { to: request.to },
+    ...request.limitPerSeries === undefined ? {} : { limitPerSeries: request.limitPerSeries },
+    ...request.order === undefined ? {} : { order: request.order }
+  });
+  const stored = series.length === 0 ? [] : await storage.getHistoryBatch(providerRequest);
+  if (!Array.isArray(stored))
+    throw invalidTimeseriesProviderResult();
+  const storedCount = stored.length;
+  if (!Number.isSafeInteger(storedCount) || storedCount > series.length) {
+    throw invalidTimeseriesProviderResult();
+  }
+  const seriesKeys = new Set(series.map(seriesKey));
+  const providerResultBySeries = new Map;
+  for (let index = 0;index < storedCount; index += 1) {
+    const providerResult = snapshotProviderResult(stored[index], request.limitPerSeries);
+    const key = seriesKey(providerResult);
+    if (providerResultBySeries.has(key) || !seriesKeys.has(key)) {
+      throw invalidTimeseriesProviderResult();
+    }
+    for (const point of providerResult.points) {
+      assertTimeseriesPointMatchesSeries(projectId, providerResult, point);
+    }
+    providerResultBySeries.set(key, providerResult);
+  }
+  return providerResultBySeries;
+}
+function assembleHistoryResults(input) {
+  const { request, resultsBySeries, releasableSeries } = input;
+  const releasableSeriesKeys = new Set(releasableSeries.map(seriesKey));
+  const releasedPoints = request.series.map((series) => releasableSeriesKeys.has(seriesKey(series)) ? resultsBySeries.get(seriesKey(series))?.points ?? [] : []);
+  const pointOccurrences = releasedPoints.reduce((total, points) => total + points.length, 0);
+  if (request.maxPointOccurrences !== undefined && pointOccurrences > request.maxPointOccurrences) {
+    throw invalidTimeseriesProviderResult();
+  }
+  return request.series.map((series, index) => ({
+    ...series,
+    points: releasedPoints[index].map((point) => structuredClone(point))
+  }));
+}
+function snapshotTelemetrySeries(series) {
+  if (typeof series !== "object" || series === null || Array.isArray(series)) {
+    throw new Error("[Sixb] Telemetry history series must be an object.");
+  }
+  const objectTypeId = telemetryIdentifier(series.objectTypeId, "objectTypeId");
+  const objectId = telemetryIdentifier(series.objectId, "objectId");
+  const propertyId = telemetryIdentifier(series.propertyId, "propertyId");
+  return structuredClone({ objectTypeId, objectId, propertyId });
+}
+function assertTimeseriesPointMatchesSeries(projectId, series, point) {
+  if (typeof point !== "object" || point === null || point.projectId !== projectId || point.objectTypeId !== series.objectTypeId || point.objectId !== series.objectId || point.propertyId !== series.propertyId) {
+    throw invalidTimeseriesProviderResult();
+  }
+}
+function snapshotTelemetryHistoryInput(input, objectReader) {
+  const authoredSeries = input.series;
+  const from = input.from;
+  const to = input.to;
+  const limitPerSeries = input.limitPerSeries;
+  const order = input.order;
+  if (!Array.isArray(authoredSeries)) {
+    throw new Error("[Sixb] Telemetry history series must be an array.");
+  }
+  if (order !== undefined && order !== "asc" && order !== "desc") {
+    throw new Error("[Sixb] Telemetry history order must be 'asc' or 'desc'.");
+  }
+  const seriesCount = authoredSeries.length;
+  const admission = objectReader.admitTelemetryHistoryRead({
+    seriesCount,
+    ...limitPerSeries === undefined ? {} : { limitPerSeries }
+  });
+  const series = [];
+  for (let index = 0;index < seriesCount; index += 1) {
+    series.push(snapshotTelemetrySeries(authoredSeries[index]));
+  }
+  return structuredClone({
+    series,
+    ...from === undefined ? {} : { from },
+    ...to === undefined ? {} : { to },
+    ...admission.limitPerSeries === undefined ? {} : { limitPerSeries: admission.limitPerSeries },
+    ...order === undefined ? {} : { order },
+    ...admission.maxPointOccurrences === undefined ? {} : { maxPointOccurrences: admission.maxPointOccurrences }
+  });
 }
-function assertTelemetrySeriesViewable(series, authorization) {
-  for (const objectTypeId of new Set(series.map((entry) => entry.objectTypeId))) {
-    assertAuthorized({
-      runtimeAuthorization: authorization.runtimeAuthorization,
-      authorization: authorization.authorization ?? undefined
-    }, { kind: "object.view", objectTypeId });
+function objectPropertySelection(series) {
+  return {
+    objectTypeId: series.objectTypeId,
+    primaryId: series.objectId,
+    propertyId: series.propertyId
+  };
+}
+function visibleLatestResult(result, objectReader) {
+  objectReader.assertVisibleOutputWithinLimit(result);
+  return result;
+}
+function snapshotProviderResult(result, maxPointsPerSeries) {
+  try {
+    if (typeof result !== "object" || result === null || Array.isArray(result)) {
+      throw invalidTimeseriesProviderResult();
+    }
+    const series = snapshotTelemetrySeries(result);
+    const authoredPoints = result.points;
+    if (!Array.isArray(authoredPoints))
+      throw invalidTimeseriesProviderResult();
+    const pointCount = authoredPoints.length;
+    if (!Number.isSafeInteger(pointCount) || maxPointsPerSeries !== undefined && pointCount > maxPointsPerSeries) {
+      throw invalidTimeseriesProviderResult();
+    }
+    const points = [];
+    for (let index = 0;index < pointCount; index += 1) {
+      points.push(snapshotProviderPoint(authoredPoints[index]));
+    }
+    return { ...series, points };
+  } catch (error) {
+    if (isInvalidTimeseriesProviderResult(error))
+      throw error;
+    throw invalidTimeseriesProviderResult(error);
+  }
+}
+function snapshotProviderPoint(point) {
+  try {
+    const snapshot = structuredClone(point);
+    if (!snapshot || typeof snapshot !== "object")
+      throw invalidTimeseriesProviderResult();
+    return snapshot;
+  } catch (error) {
+    if (isInvalidTimeseriesProviderResult(error))
+      throw error;
+    throw invalidTimeseriesProviderResult(error);
+  }
+}
+function invalidTimeseriesProviderResult(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.";
+}
+function telemetryIdentifier(value, field) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`[Sixb] Telemetry history ${field} must be a non-empty string.`);
   }
+  return value;
+}
+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 },
@@ -592,20 +795,23 @@ function createTelemetryChannel(ctx, primaryId) {
       },
       history: async (input = {}) => {
         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 [result] = await getTelemetryHistoryBatch({
-          projectId: ctx.projectId,
+        const from = input.from;
+        const to = input.to;
+        const limit = input.limit;
+        const order = input.order;
+        const [result] = await getTelemetryHistoryBatch2({
           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 } : {}
+          ...from !== undefined ? { from } : {},
+          ...to !== undefined ? { to } : {},
+          ...limit !== undefined ? { limitPerSeries: limit } : {},
+          ...order !== undefined ? { order } : {}
         }, {
           storage: timeseries,
-          runtimeAuthorization: ctx.runtimeAuthorization,
-          authorization: ctx.authorization
+          objectReader
         });
         return (result?.points ?? []).map((point) => ({
           value: point.value,
@@ -622,30 +828,26 @@ function createTelemetryChannel(ctx, primaryId) {
 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,
+      const row = await ctx.objectReader.getByPrimaryId({
         objectTypeId: ctx.objectType.id,
         primaryId
       });
       return row ? row : null;
     },
     listLinks: async (linkToken) => {
-      assertPrivileged(ctx, "listLinks");
       if (linkToken) {
-        assertLinkTokenBelongsToObjectType(ctx.objectType, linkToken);
+        assertLinkTokenBelongsToObjectType2(ctx.objectType, linkToken);
       }
-      return ctx.storage.objects.listLinks({
-        projectId: ctx.projectId,
+      return ctx.objectReader.listLinks({
         objectTypeId: ctx.objectType.id,
         objectId: primaryId,
         linkId: linkToken?.id
       });
     },
     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,
@@ -654,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,
@@ -664,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,
@@ -684,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,
@@ -703,62 +905,60 @@ function createObjectByIdHandle(ctx, primaryId) {
 
 // src/objects/sdk/runtime-query-executor.ts
 function createRuntimeQueryExecutor(params) {
-  const { projectId, ontology, storage, runtimeAuthorization, authorization } = params;
-  const executorOptions = {
-    ontology,
-    storage: storage.objects,
-    runtimeAuthorization,
-    authorization
-  };
+  const { ontology, objectReader } = params;
   return {
     async list(query, options) {
       try {
-        return await executeObjectQuery({ projectId, query, includeTotal: options?.includeTotal }, executorOptions);
+        return await objectReader.executeQuery({ query, includeTotal: options?.includeTotal });
       } catch (error) {
-        if (error instanceof ObjectQueryPlanningError) {
+        if (error instanceof ObjectQueryPlanningError2) {
           throw addSdkPlanningHints(error);
         }
         throw error;
       }
     },
     async count(query) {
-      const result = await countObjects({ projectId, query }, executorOptions);
+      const result = await objectReader.count({ query });
       return result.count;
     },
     async exists(query) {
-      const result = await existsObjects({ projectId, query }, executorOptions);
+      const result = await objectReader.exists({ query });
       return result.exists;
     },
     async facets(query, facets) {
-      const result = await facetObjects({ projectId, query, facets }, executorOptions);
+      const result = await objectReader.facet({ query, facets });
       return result.facets.map((facet) => ({
         propertyId: facet.propertyId,
         buckets: [...facet.buckets]
       }));
     },
     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 }
+  });
   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 {
@@ -769,16 +969,14 @@ function createObjectSet(params) {
     events,
     storage,
     queues,
+    objectReader,
     runtimeAuthorization,
     authorization,
     execution
   } = params;
   const queryExecutor = createRuntimeQueryExecutor({
-    projectId,
     ontology,
-    storage,
-    runtimeAuthorization,
-    authorization
+    objectReader
   });
   const resolvedCtx = {
     projectId,
@@ -788,37 +986,34 @@ function createObjectSet(params) {
     events,
     storage,
     queues,
+    objectReader,
     runtimeAuthorization,
     authorization,
     execution,
     objectType,
     primaryPropertyId
   };
-  shareOntologyMutationRuntime(params, resolvedCtx);
-  shareSixbErrorReporter(params, resolvedCtx);
+  shareOntologyMutationRuntime2(params, resolvedCtx);
+  shareSixbErrorReporter2(params, resolvedCtx);
   const objectSet = {
     get: async (id) => {
-      assertAuthorized(resolvedCtx, { kind: "object.view", objectTypeId: objectType.id });
-      const row = await storage.objects.getByPrimaryId({
-        projectId,
+      const row = await objectReader.getByPrimaryId({
         objectTypeId: objectType.id,
         primaryId: id
       });
       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
     }),
     byId: (id) => createObjectByIdHandle(resolvedCtx, id),
     list: async (input) => {
-      assertAuthorized(resolvedCtx, { kind: "object.view", objectTypeId: objectType.id });
-      const result = await storage.objects.list({
-        projectId,
+      const result = await objectReader.list({
         objectTypeId: objectType.id,
         primaryIdPrefix: input?.idPrefix,
         primaryIdSuffix: input?.idSuffix,
@@ -838,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,
@@ -855,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,
@@ -868,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,
@@ -879,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,
@@ -894,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,
@@ -926,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,
@@ -940,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,
@@ -954,12 +1149,11 @@ async function removeLink2(runtime, objectTypeId, sourceId, linkId, target) {
 }
 // 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) {
+  const objectTypeIds = resolveTypeFilter(runtime, params.objectTypeIds);
+  if (objectTypeIds !== undefined && objectTypeIds.length === 0) {
     return { objects: [], hasMore: false, total: 0 };
   }
-  const result = await runtime.storage.objects.list({
-    projectId: runtime.projectId,
+  const result = await runtime.objectReader.list({
     objectTypeId: objectTypeIds?.length === 1 ? objectTypeIds[0] : objectTypeIds,
     primaryIdPrefix: params.idPrefix,
     primaryIdSuffix: params.idSuffix,
@@ -978,36 +1172,27 @@ async function listObjects(runtime, params) {
     total: result.total
   };
 }
-function resolveAuthorizedTypeFilter(runtime, requested) {
+function resolveTypeFilter(runtime, requested) {
+  const ontology = resolveRuntimeAuthorizationForProject(runtime).type === "delegated" ? getAuthorizedOntologyView(runtime.objectReader) : runtime.ontology;
   if (requested) {
     for (const objectTypeId of requested) {
-      runtime.ontology.resolveObjectType(objectTypeId);
+      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;
+  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, 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=907DECCEF177EB6A64756E2164756E21
+//# debugId=0ED9DE016D18A46464756E2164756E21