@sixb/core 0.1.18 → 0.1.19

package/dist/chunk-qxvp5epv.js

@@ -1,1329 +0,0 @@
-// @bun
-import {
-  createSixbError2
-} from "./chunk-6fsr7y93.js";
-import {
-  resolveRuntimeAuthorizationForProject,
-  AuthorizationError2,
-  assertAuthorized2,
-  assertCanEdit2,
-  assertCanAppendTelemetry2
-} from "./chunk-qkbx3tf6.js";
-import {
-  assertValidFileRefs2,
-  normalizeObjectProperties2,
-  assertPropertyTokenBelongsToObjectType2,
-  assertLinkTokenBelongsToObjectType2,
-  assertKnownProperties2,
-  validateObjectProperties2,
-  assertLinkTargetType2,
-  normalizeLinkProperties2,
-  validateLinkProperties2,
-  assertTelemetryProperty2
-} from "./chunk-y05543x6.js";
-import {
-  linkRefKey2,
-  telemetryPointKey2
-} from "./chunk-b9affek3.js";
-import {
-  objectBatchKey2,
-  vectorConfiguration,
-  vectorSources,
-  normalizeVector2
-} from "./chunk-qq90g05n.js";
-import {
-  validateObjectQuery2,
-  explainObjectQuery2
-} from "./chunk-htr6wjmv.js";
-import {
-  assertAuthorizedObjectReaderBinding,
-  getAuthorizedOntologyView,
-  requestAction3,
-  requestActionAndWait2
-} from "./chunk-fx93hd2n.js";
-import {
-  shareSixbErrorReporter2
-} from "./chunk-vjcd8d27.js";
-import {
-  normalizeJsonProperties2
-} from "./chunk-p0dqwj3n.js";
-import {
-  getOntologyMutationRuntime2,
-  shareOntologyMutationRuntime2
-} from "./chunk-85cd7e8c.js";
-import {
-  resolveFileRefAtPath2,
-  openFileRef2,
-  jsonPointerSegment2
-} from "./chunk-3zxk45er.js";
-import {
-  createObjectQueryBuilder2
-} from "./chunk-ewqa58h9.js";
-import {
-  ObjectQueryPlanningError2
-} from "./chunk-kpx7jrmn.js";
-import {
-  ObjectNotFoundError2
-} from "./chunk-y9jmd7e5.js";
-import {
-  MaterializationValidationError2,
-  MaterializationObjectNotFoundError2
-} from "./chunk-96yw3pwd.js";
-import {
-  RuntimeError2
-} from "./chunk-m4ehq95f.js";
-import {
-  OntologyValidationError2,
-  OntologyNotFoundError2
-} from "./chunk-cqr3acm1.js";
-import {
-  sameEmbeddingModel
-} from "./chunk-kyjcwqz6.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 requestAction3(ctx, ctx.execution, {
-    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 requestActionAndWait(ctx, params) {
-  return requestActionAndWait2(ctx, ctx.execution, {
-    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/errors.ts
-class ObjectError2 extends Error {
-  name = "ObjectError";
-}
-
-// src/objects/materializer-adapter.ts
-import { randomUUID } from "crypto";
-async function commitRuntimeOperations(ctx, operations) {
-  const mutations = getOntologyMutationRuntime2(ctx);
-  const commit = await mutations.commitEdits({
-    mode: "atomic",
-    source: { kind: "runtime", requestId: randomUUID() },
-    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 = getOntologyMutationRuntime2(ctx);
-  const commit = await mutations.commitEdits({
-    mode: "continue",
-    source: { kind: "runtime", requestId: randomUUID() },
-    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;
-  assertKnownProperties2(objectType, properties);
-  validateObjectProperties2(objectType, properties, valueTypesById);
-  assertValidFileRefs2(properties, objectType.id);
-  const primaryValue = properties[primaryPropertyId];
-  if (primaryValue === undefined || primaryValue === null) {
-    throw new OntologyValidationError2(`[Sixb] Missing primary property '${primaryPropertyId}' in upsert for '${objectType.id}'`);
-  }
-  const normalized = normalizeObjectProperties2(objectType.properties, properties, valueTypesById, objectType.id);
-  const { [primaryPropertyId]: _identity, ...managed } = normalized;
-  return {
-    primaryId: String(primaryValue),
-    properties: normalizeJsonProperties2(managed, `${objectType.id} properties`)
-  };
-}
-function normalizeRuntimeLink(input) {
-  const { objectType, linkDefinition, linkId, targetTypeId, properties, valueTypesById } = input;
-  assertLinkTargetType2(objectType.id, linkId, linkDefinition, targetTypeId, input.isValidLinkTarget);
-  validateLinkProperties2(objectType, linkDefinition, properties, undefined, valueTypesById);
-  assertValidFileRefs2(properties, `${objectType.id}.${linkId}`);
-  const normalized = normalizeLinkProperties2(objectType, linkDefinition, properties, valueTypesById);
-  if (normalized === undefined)
-    return;
-  return normalizeJsonProperties2(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 ObjectError2(`[Sixb] Materializer returned no outcome for batch item ${index}.`);
-  }
-  return outcomes;
-}
-function requireEffectiveObject(outcome) {
-  if (!outcome.ok || !outcome.object) {
-    throw new ObjectError2(`[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 OntologyValidationError2(error.message);
-  }
-}
-function requireOutcome(outcomes, id) {
-  const outcome = outcomes.get(id);
-  if (!outcome) {
-    throw new ObjectError2(`[Sixb] Materializer returned no outcome for '${id}'.`);
-  }
-  return outcome;
-}
-
-// src/objects/link/authorization.ts
-function assertCanWriteLink(ctx, endpoints) {
-  assertCanEdit2(ctx, endpoints.sourceTypeId);
-  assertAuthorized2(ctx, { kind: "object.view", objectTypeId: endpoints.targetTypeId });
-}
-
-// src/objects/link/remove.ts
-async function removeLink2(ctx, params) {
-  const { objectType, linkDefinition, ontology } = ctx;
-  const { sourceId, linkId, targetTypeId, targetId } = params;
-  assertCanWriteLink(ctx, { sourceTypeId: objectType.id, targetTypeId });
-  assertLinkTargetType2(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 ObjectNotFoundError2(item.objectType.id, item.sourceId, "Source object not found");
-  }
-  if (!existing.has(endpointKey(item.targetTypeId, item.targetId))) {
-    throw new ObjectNotFoundError2(item.targetTypeId, item.targetId, "Target object not found");
-  }
-}
-function endpointKey(objectTypeId, primaryId) {
-  return objectBatchKey2(objectTypeId, primaryId);
-}
-
-// src/objects/link/upsert.ts
-async function upsertLink2(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 OntologyValidationError2(`[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 upsertLinkBatch2(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 = linkRefKey2(ref);
-      return {
-        key: edge,
-        label: `link '${item.objectType.id}:${item.sourceId}.${item.linkId} -> ${item.targetTypeId}:${item.targetId}'`,
-        fingerprint: stableJsonStringify2(properties ?? null),
-        operations: [
-          linkUpsertOperation({
-            id: runtimeOperationId(index),
-            ref,
-            ...properties !== undefined ? { properties } : {}
-          })
-        ]
-      };
-    },
-    value: () => {
-      return;
-    }
-  });
-}
-// src/objects/object/delete.ts
-async function deleteObject2(ctx, primaryId) {
-  assertCanEdit2(ctx, ctx.objectType.id);
-  await commitRuntimeOperations(ctx, [
-    objectDeleteOperation({
-      id: runtimeOperationId(0),
-      ref: { objectTypeId: ctx.objectType.id, primaryId }
-    })
-  ]);
-}
-async function restoreObject2(ctx, primaryId) {
-  assertCanEdit2(ctx, ctx.objectType.id);
-  await commitRuntimeOperations(ctx, [
-    objectRestoreOperation({
-      id: runtimeOperationId(0),
-      ref: { objectTypeId: ctx.objectType.id, primaryId }
-    })
-  ]);
-}
-
-// src/objects/object/upsert.ts
-async function upsertObject2(ctx, properties) {
-  assertCanEdit2(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 ctx.objectReader.redactWrittenRow(toObjectRow(ctx.projectId, requireEffectiveObject(commit.outcomes[0])));
-}
-
-// src/objects/object/upsert-batch.ts
-async function upsertObjectBatch2(ctx, items) {
-  assertCanEdit2(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: stableJsonStringify2(normalized.properties),
-        operations: [
-          objectUpsertOperation({
-            id: runtimeOperationId(index),
-            ref,
-            properties: normalized.properties
-          })
-        ]
-      };
-    },
-    value: ([outcome]) => ctx.objectReader.redactWrittenRow(toObjectRow(ctx.projectId, requireEffectiveObject(outcome)))
-  });
-}
-// src/objects/telemetry/write-batch.ts
-import { randomUUID as randomUUID2 } from "crypto";
-async function writeTelemetryBatch2(ctx, points) {
-  for (const objectTypeId of new Set(points.map((point) => point.series.object.objectTypeId))) {
-    assertCanAppendTelemetry2(ctx, objectTypeId);
-  }
-  if (points.length === 0)
-    return null;
-  let commit;
-  try {
-    commit = await getOntologyMutationRuntime2(ctx).appendTelemetry({
-      source: { kind: "runtime", requestId: randomUUID2() },
-      points
-    });
-  } catch (error) {
-    if (error instanceof MaterializationObjectNotFoundError2) {
-      throw new ObjectNotFoundError2(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 appendTelemetryBatch2(ctx, items) {
-  assertCanAppendTelemetry2(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 OntologyValidationError2(`Unknown property '${objectType.id}.${propertyId}'`);
-      }
-      assertTelemetryProperty2(propertyToken.property);
-      const series = {
-        object: { objectTypeId: objectType.id, primaryId: item.id },
-        propertyId: propertyToken.id
-      };
-      points.set(telemetryPointKey2(series, at), {
-        series,
-        value: isUnitBearingValue(rawValue) ? rawValue.value : rawValue,
-        ...isUnitBearingValue(rawValue) ? { unit: rawValue.unit } : {},
-        at
-      });
-    }
-  }
-  await writeTelemetryBatch2(ctx, [...points.values()]);
-}
-
-// src/objects/telemetry/history.ts
-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 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 requireLinkDefinition2(objectType, linkId) {
-  const def = objectType.links.find((l) => l.id === linkId);
-  if (!def)
-    throw new OntologyNotFoundError2(`Unknown link '${objectType.id}.${linkId}'`);
-  return def;
-}
-function resolveObjectContext2(runtime, objectTypeId) {
-  const objectType = runtime.ontology.resolveObjectType(objectTypeId);
-  const primaryPropertyId = runtime.ontology.getPrimaryPropertyId(objectTypeId);
-  return { ...runtime, objectType, primaryPropertyId };
-}
-function resolveLinkContext2(objCtx, linkId) {
-  const linkDefinition = requireLinkDefinition2(objCtx.objectType, linkId);
-  return { ...objCtx, linkDefinition };
-}
-// src/objects/vectors/handle.ts
-import { randomUUID as randomUUID3 } from "crypto";
-function createObjectVectorHandle(ctx, primaryId, profileName) {
-  const ref = Object.freeze({ objectTypeId: ctx.objectType.id, primaryId });
-  const profileDefinition = ctx.ontology.resolveObjectType(ref.objectTypeId).search?.vectors?.[profileName];
-  if (!profileDefinition)
-    throw new MaterializationValidationError2(`Unknown vector profile: ${profileName}`);
-  const vectors = ctx.storage.ontology.vectors;
-  if (!vectors)
-    throw new MaterializationValidationError2("Storage does not support vector profiles.");
-  const assertReadable = async () => {
-    const allowed = await ctx.objectReader.canReadObjectPropertiesBatch({
-      items: profileDefinition.source.map((propertyId) => ({ ...ref, propertyId }))
-    });
-    if (allowed.some((value) => !value))
-      throw new AuthorizationError2(`view:object:${ref.objectTypeId}`, "[Sixb] Vector profile requires access to all its source properties.");
-  };
-  return Object.freeze({
-    async index() {
-      assertCanEdit2(ctx, ref.objectTypeId);
-      await assertReadable();
-      const mutations = getOntologyMutationRuntime2(ctx);
-      const model = ctx.embeddingModels?.getByRef({
-        provider: profileDefinition.model.providerId,
-        modelId: profileDefinition.model.modelId
-      })?.model;
-      if (!model || !sameEmbeddingModel(model, profileDefinition.model)) {
-        throw new MaterializationValidationError2(`Vector profile '${profileName}' requires its configured embedding model.`);
-      }
-      const row = await ctx.objectReader.getByPrimaryId(ref);
-      if (!row)
-        throw new MaterializationValidationError2("Cannot index a missing object.");
-      const current = (await vectors.list({ projectId: ctx.projectId, ref })).find((entry) => entry.profile === profileName);
-      const input = {
-        projectId: ctx.projectId,
-        ref,
-        profile: profileName,
-        configuration: vectorConfiguration(profileDefinition),
-        ...vectorSources(profileDefinition.source, row.properties),
-        expectedObject: { ref, exists: true, version: row.version, lastCommitId: row.lastCommitId },
-        expectedVectorCommitId: current?.lastCommitId ?? null
-      };
-      const result = await model.embed({ texts: [input.text], purpose: "document" });
-      if (!Array.isArray(result?.vectors) || result.vectors.length !== 1) {
-        throw new MaterializationValidationError2("Embedding model must return exactly one vector for one input text.");
-      }
-      const values = normalizeVector2(result.vectors[0], profileDefinition.model.definition.dimensions);
-      assertCanEdit2(ctx, ref.objectTypeId);
-      await assertReadable();
-      await mutations.commitEdits({
-        mode: "atomic",
-        source: { kind: "runtime", requestId: randomUUID3() },
-        operations: [],
-        vectorWrites: [{ input, values }],
-        expectedObjects: [input.expectedObject],
-        expectedLinks: [],
-        expectedLinkScopes: []
-      });
-    }
-  });
-}
-
-// src/objects/sdk/file-handle.ts
-function createObjectFileHandle(ctx, primaryId, property, index) {
-  const { objectType } = ctx;
-  assertPropertyTokenBelongsToObjectType2(objectType, property);
-  const registered = ctx.ontology.resolveObjectType(objectType.id).properties.find((candidate) => candidate.id === property.id);
-  if (!registered) {
-    throw new OntologyValidationError2(`[Sixb] Unknown property '${property.id}' for object type '${objectType.id}'`);
-  }
-  const path = filePropertyPath(objectType.id, registered, index);
-  return {
-    async open() {
-      const row = await ctx.objectReader.getByPrimaryId({ objectTypeId: objectType.id, primaryId });
-      if (!row)
-        return null;
-      if (row.redactions?.[property.id]) {
-        const markings = registered.markings ?? [];
-        const marking = markings.find((markingId) => !ctx.authorization?.clearances?.has(markingId)) ?? markings[0];
-        throw new AuthorizationError2(`clearance:marking:${marking}`, `[Sixb] Cannot open file '${objectType.id}.${property.id}': it requires clearance for marking '${marking}'.`);
-      }
-      const fileRef = resolveFileRefAtPath2(row, path);
-      return fileRef ? openFileRef2(ctx.blobStorage, fileRef) : null;
-    }
-  };
-}
-function filePropertyPath(objectTypeId, property, index) {
-  const { schema } = property;
-  const name = `${objectTypeId}.${property.id}`;
-  if (schema === "fileRef") {
-    if (index !== undefined) {
-      throw new OntologyValidationError2(`[Sixb] Property ${name} holds one file; omit the index.`);
-    }
-    return `/properties/${jsonPointerSegment2(property.id)}`;
-  }
-  if (typeof schema === "object" && schema.type === "array" && schema.items === "fileRef") {
-    if (index === undefined || !Number.isSafeInteger(index) || index < 0) {
-      throw new OntologyValidationError2(`[Sixb] Property ${name} holds a list of files; pass the index of the file to open.`);
-    }
-    return `/properties/${jsonPointerSegment2(property.id)}/${index}`;
-  }
-  throw new OntologyValidationError2(`[Sixb] Property ${name} is not a file: file() takes a "fileRef" property or a list of them.`);
-}
-
-// src/objects/sdk/telemetry-channel.ts
-function createTelemetryChannel(ctx, primaryId) {
-  return (property) => {
-    const { objectType } = ctx;
-    assertPropertyTokenBelongsToObjectType2(objectType, property);
-    assertTelemetryProperty2(property.property);
-    const series = { objectTypeId: objectType.id, objectId: primaryId, propertyId: property.id };
-    const channel = {
-      append: async (input) => {
-        await writeTelemetryBatch2(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;
-        const objectReader = ctx.objectReader;
-        if (!timeseries) {
-          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 getTelemetryHistoryBatch2({
-          series: [series],
-          ...from !== undefined ? { from } : {},
-          ...to !== undefined ? { to } : {},
-          ...limit !== undefined ? { limitPerSeries: limit } : {},
-          ...order !== undefined ? { order } : {}
-        }, {
-          storage: timeseries,
-          objectReader
-        });
-        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 = {
-    vector: (profileName) => createObjectVectorHandle(ctx, primaryId, profileName),
-    get: async () => {
-      const row = await ctx.objectReader.getByPrimaryId({
-        objectTypeId: ctx.objectType.id,
-        primaryId
-      });
-      return row ? row : null;
-    },
-    listLinks: async (linkToken) => {
-      if (linkToken) {
-        assertLinkTokenBelongsToObjectType2(ctx.objectType, linkToken);
-      }
-      return ctx.objectReader.listLinks({
-        objectTypeId: ctx.objectType.id,
-        objectId: primaryId,
-        linkId: linkToken?.id
-      });
-    },
-    link: async (linkToken, target, options) => {
-      assertLinkTokenBelongsToObjectType2(ctx.objectType, linkToken);
-      const linkCtx = { ...ctx, linkDefinition: linkToken.link };
-      await upsertLink2(linkCtx, {
-        sourceId: primaryId,
-        linkId: linkToken.id,
-        targetTypeId: target.objectTypeId,
-        targetId: target.primaryId,
-        properties: options?.properties
-      });
-    },
-    unlink: async (linkToken, target) => {
-      assertLinkTokenBelongsToObjectType2(ctx.objectType, linkToken);
-      const linkCtx = { ...ctx, linkDefinition: linkToken.link };
-      await removeLink2(linkCtx, {
-        sourceId: primaryId,
-        linkId: linkToken.id,
-        targetTypeId: target.objectTypeId,
-        targetId: target.primaryId
-      });
-    },
-    delete: async () => {
-      await deleteObject2(ctx, primaryId);
-    },
-    restore: async () => {
-      await restoreObject2(ctx, primaryId);
-    },
-    requestAction: async (input) => {
-      const actionId = input.action?.id ?? input.actionId;
-      if (!actionId) {
-        throw new OntologyValidationError2("[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 OntologyValidationError2("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
-      }
-      return requestActionAndWait(ctx, {
-        primaryId,
-        actionId,
-        params: input.params,
-        options: {
-          timeoutMs: input.timeoutMs,
-          signal: input.signal
-        }
-      });
-    },
-    telemetry: createTelemetryChannel(ctx, primaryId),
-    file: (property, index) => createObjectFileHandle(ctx, primaryId, property, index)
-  };
-  return objectHandle;
-}
-
-// src/objects/sdk/runtime-query-executor.ts
-function createRuntimeQueryExecutor(params) {
-  const { ontology, objectReader } = params;
-  return {
-    async list(query, options) {
-      try {
-        return await objectReader.executeQuery({
-          query,
-          includeTotal: options?.includeTotal,
-          signal: options?.signal
-        });
-      } catch (error) {
-        if (error instanceof ObjectQueryPlanningError2) {
-          throw addSdkPlanningHints(error);
-        }
-        throw error;
-      }
-    },
-    async count(query) {
-      const result = await objectReader.count({ query });
-      return result.count;
-    },
-    async exists(query) {
-      const result = await objectReader.exists({ query });
-      return result.exists;
-    },
-    async facets(query, facets) {
-      const result = await objectReader.facet({ query, facets });
-      return {
-        total: result.total,
-        facets: result.facets.map((facet) => ({
-          propertyId: facet.propertyId,
-          buckets: [...facet.buckets]
-        }))
-      };
-    },
-    validate(query) {
-      return validateObjectQuery2(query, { ontology, normalize: false });
-    },
-    explain(query) {
-      return explainObjectQuery2(query, { ontology, normalize: false });
-    }
-  };
-}
-function addSdkPlanningHints(error) {
-  if (!error.issues.some((issue) => issue.code === "fallback_requires_bound"))
-    return error;
-  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 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 OntologyValidationError2(`Object type '${objectType.id}' has no primary property`);
-  }
-  const primaryPropertyId = primaryProp.id;
-  const {
-    projectId,
-    broker,
-    ontology,
-    actionRegistry,
-    events,
-    storage,
-    queues,
-    objectReader,
-    runtimeAuthorization,
-    authorization,
-    execution
-  } = params;
-  const queryExecutor = createRuntimeQueryExecutor({
-    ontology,
-    objectReader
-  });
-  const resolvedCtx = {
-    embeddingModels: params.embeddingModels,
-    projectId,
-    broker,
-    ontology,
-    actionRegistry,
-    events,
-    storage,
-    queues,
-    objectReader,
-    runtimeAuthorization,
-    authorization,
-    execution,
-    blobStorage: params.blobStorage,
-    objectType,
-    primaryPropertyId
-  };
-  shareOntologyMutationRuntime2(params, resolvedCtx);
-  shareSixbErrorReporter2(params, resolvedCtx);
-  const objectSet = {
-    get: async (id) => {
-      const row = await objectReader.getByPrimaryId({
-        objectTypeId: objectType.id,
-        primaryId: id
-      });
-      return row ? row : null;
-    },
-    upsert: async (input) => {
-      const row = await upsertObject2(resolvedCtx, input.properties);
-      return row;
-    },
-    query: () => createObjectQueryBuilder2({
-      query: { kind: "start", objectTypeId: objectType.id },
-      executor: queryExecutor
-    }),
-    byId: (id) => createObjectByIdHandle(resolvedCtx, id),
-    list: async (input) => {
-      const result = await objectReader.list({
-        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 appendTelemetryBatch2(resolvedCtx, items);
-    },
-    requestAction: async (input) => {
-      const actionId = input.action?.id ?? input.actionId;
-      if (!actionId) {
-        throw new OntologyValidationError2("[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 OntologyValidationError2("[Sixb] requestActionAndWait requires either 'action' or 'actionId'");
-      }
-      return requestActionAndWait(resolvedCtx, {
-        primaryId: input.id,
-        actionId,
-        params: input.params,
-        options: {
-          timeoutMs: input.timeoutMs,
-          signal: input.signal
-        }
-      });
-    },
-    upsertLink: async (input) => {
-      const linkDefinition = requireLinkDefinition2(objectType, input.linkId);
-      const linkCtx = { ...resolvedCtx, linkDefinition };
-      await upsertLink2(linkCtx, {
-        sourceId: input.sourceId,
-        linkId: input.linkId,
-        targetTypeId: input.targetTypeId,
-        targetId: input.targetId,
-        properties: input.properties
-      });
-    },
-    removeLink: async (input) => {
-      const linkDefinition = requireLinkDefinition2(objectType, input.linkId);
-      const linkCtx = { ...resolvedCtx, linkDefinition };
-      await removeLink2(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, {
-  appendTelemetry: () => appendTelemetry,
-  listObjects: () => listObjects,
-  removeLink: () => removeLink3,
-  requestAction: () => requestAction,
-  requestActionAndWait: () => requestActionAndWait3,
-  upsertLink: () => upsertLink3,
-  upsertLinkBatch: () => upsertLinkBatch3,
-  upsertObject: () => upsertObject3,
-  upsertObjectBatch: () => upsertObjectBatch3
-});
-
-// src/objects/service/action-service.ts
-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 = { ...resolveObjectContext2(runtime, objectTypeId), execution };
-  return requestActionAndWait(ctx, { primaryId, actionId, params, options });
-}
-// src/objects/service/link-service.ts
-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,
-    targetId: target.targetId,
-    properties: target.properties
-  });
-}
-async function upsertLinkBatch3(runtime, items) {
-  const resolvedItems = items.map((item) => {
-    const objectType = runtime.ontology.resolveObjectType(item.objectTypeId);
-    const linkDefinition = requireLinkDefinition2(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 upsertLinkBatch2(runtime, resolvedItems);
-}
-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,
-    targetId: target.targetId
-  });
-}
-// src/objects/service/list-service.ts
-async function listObjects(runtime, params) {
-  const objectTypeIds = resolveTypeFilter(runtime, params.objectTypeIds);
-  if (objectTypeIds !== undefined && objectTypeIds.length === 0) {
-    return { objects: [], hasMore: false, total: 0 };
-  }
-  const result = await runtime.objectReader.list({
-    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 resolveTypeFilter(runtime, requested) {
-  const ontology = resolveRuntimeAuthorizationForProject(runtime).type === "delegated" ? getAuthorizedOntologyView(runtime.objectReader) : runtime.ontology;
-  if (requested) {
-    for (const objectTypeId of requested) {
-      ontology.resolveObjectType(objectTypeId);
-    }
-  }
-  return requested ? [...new Set(requested.flatMap((id) => [id, ...ontology.listSubTypes(id)]))] : undefined;
-}
-// src/objects/service/object-service.ts
-async function upsertObject3(runtime, objectTypeId, properties) {
-  return upsertObject2(resolveObjectContext2(runtime, objectTypeId), properties);
-}
-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 = resolveObjectContext2(runtime, objectTypeId);
-  await appendTelemetryBatch2(ctx, items);
-}
-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=90347800675626DB64756E2164756E21