@sixb/core 0.1.8 → 0.1.10

package/dist/{chunk-p1x242ad.js → chunk-dz5h08xv.js}

@@ -1,22 +1,22 @@
 // @bun
 import {
-  compileSelectedObjectReadScope
-} from "./chunk-r8jrnexe.js";
+  createSixbError2
+} from "./chunk-f4w3yp4f.js";
 import {
-  resolveSemanticType
-} from "./chunk-h0k55pc7.js";
+  compileSelectedObjectReadScope2
+} from "./chunk-v4jbb3rs.js";
 import {
-  createSixbError
-} from "./chunk-2xns679x.js";
+  resolveSemanticType2
+} from "./chunk-ms2tmn1k.js";
 import {
   compareStrings
-} from "./chunk-n6jxh8sw.js";
+} from "./chunk-wy0qdqfm.js";
 
 // src/execution/authorization.ts
 import { isDeepStrictEqual } from "util";
 
 // src/agents/identity.ts
-function agentServiceAccountId(actorId) {
+function agentServiceAccountId2(actorId) {
   return `svc_agent_${actorId}`;
 }
 
@@ -144,10 +144,10 @@ function emptyGrantSets() {
 }
 
 // src/storage/objects/execution-limits.ts
-var MAX_OBJECT_READ_FACETS = 16;
+var MAX_OBJECT_READ_FACETS2 = 16;
 var MAX_OUTPUT_JSON_DEPTH = 64;
 
-class ObjectReadLimitExceededError extends Error {
+class ObjectReadLimitExceededError2 extends Error {
   metric;
   limit;
   name = "ObjectReadLimitExceededError";
@@ -158,7 +158,7 @@ class ObjectReadLimitExceededError extends Error {
     this.limit = limit;
   }
 }
-function snapshotObjectReadExecutionLimits(limits) {
+function snapshotObjectReadExecutionLimits2(limits) {
   if (typeof limits !== "object" || limits === null) {
     throw new Error("[Sixb] Object read execution limits must be provided.");
   }
@@ -167,14 +167,14 @@ function snapshotObjectReadExecutionLimits(limits) {
     maxOutputJsonBytes: positiveSafeInteger(limits.maxOutputJsonBytes, "maxOutputJsonBytes")
   });
 }
-function assertObjectReadFacetCount(count) {
-  if (!Number.isSafeInteger(count) || count < 0 || count > MAX_OBJECT_READ_FACETS) {
-    throw new Error(`[Sixb] An object read supports between 0 and ${MAX_OBJECT_READ_FACETS} facets.`);
+function assertObjectReadFacetCount2(count) {
+  if (!Number.isSafeInteger(count) || count < 0 || count > MAX_OBJECT_READ_FACETS2) {
+    throw new Error(`[Sixb] An object read supports between 0 and ${MAX_OBJECT_READ_FACETS2} facets.`);
   }
 }
-function assertObjectReadOutputWithinLimit(value, limits) {
+function assertObjectReadOutputWithinLimit2(value, limits) {
   const fail = () => {
-    throw new ObjectReadLimitExceededError("outputJsonBytes", limits.maxOutputJsonBytes);
+    throw new ObjectReadLimitExceededError2("outputJsonBytes", limits.maxOutputJsonBytes);
   };
   const stack = [];
   let bytes = 0;
@@ -278,7 +278,7 @@ function assertObjectReadOutputWithinLimit(value, limits) {
       return current;
     });
   } catch (error) {
-    if (error instanceof ObjectReadLimitExceededError)
+    if (error instanceof ObjectReadLimitExceededError2)
       throw error;
     if (error instanceof RangeError || error instanceof TypeError)
       fail();
@@ -462,8 +462,8 @@ function createDelegatedRuntimeAuthorization(input) {
     throw new Error("[Sixb] Delegated runtime authorization requires a request execution without a principal.");
   }
   const objectRead = Object.freeze({
-    scope: compileSelectedObjectReadScope(objectReadInput.selection),
-    limits: snapshotObjectReadExecutionLimits(objectReadInput.limits)
+    scope: compileSelectedObjectReadScope2(objectReadInput.selection),
+    limits: snapshotObjectReadExecutionLimits2(objectReadInput.limits)
   });
   return register(execution, {
     type: "delegated",
@@ -520,7 +520,7 @@ function snapshotSharedDelegation(input) {
 function assertExecutionScopeProject(projectId, scope) {
   assertNonEmpty(projectId, "Project id");
   if (scope.execution.projectId !== projectId) {
-    throw createSixbError("internal.unexpected", `[Sixb] Execution scope belongs to project '${scope.execution.projectId}', not '${projectId}'.`, {
+    throw createSixbError2("internal.unexpected", `[Sixb] Execution scope belongs to project '${scope.execution.projectId}', not '${projectId}'.`, {
       details: {
         executionId: scope.execution.id,
         expectedProjectId: projectId,
@@ -530,10 +530,10 @@ function assertExecutionScopeProject(projectId, scope) {
   }
   const resolved = resolveRuntimeAuthorization(scope.authorization);
   if (resolved.type === "denied") {
-    throw createSixbError("internal.unexpected", "[Sixb] Execution scope carries unregistered runtime authorization.", { details: { executionId: scope.execution.id, projectId } });
+    throw createSixbError2("internal.unexpected", "[Sixb] Execution scope carries unregistered runtime authorization.", { details: { executionId: scope.execution.id, projectId } });
   }
   if (resolved.projectId !== projectId) {
-    throw createSixbError("internal.unexpected", `[Sixb] Execution authorization belongs to project '${resolved.projectId}', not '${projectId}'.`, {
+    throw createSixbError2("internal.unexpected", `[Sixb] Execution authorization belongs to project '${resolved.projectId}', not '${projectId}'.`, {
       details: {
         authorizationProjectId: resolved.projectId,
         executionId: scope.execution.id,
@@ -552,7 +552,7 @@ function resolveExecutionScopeAuthorization(projectId, scope) {
   assertExecutionScopeProject(projectId, capturedScope);
   const resolved = resolveRuntimeAuthorization(capturedScope.authorization);
   if (resolved.type === "denied") {
-    throw createSixbError("internal.unexpected", "[Sixb] Execution scope carries unregistered runtime authorization.", { details: { executionId: capturedScope.execution.id, projectId } });
+    throw createSixbError2("internal.unexpected", "[Sixb] Execution scope carries unregistered runtime authorization.", { details: { executionId: capturedScope.execution.id, projectId } });
   }
   const registration = registeredAuthorizations.get(capturedScope.authorization);
   if (!registration || !executionMatchesBinding(registration.execution, capturedScope.execution)) {
@@ -591,7 +591,7 @@ function assertResolvedAuthorizationMatchesExecution(resolved, execution) {
       if (resolved.type === "principal" && resolved.ref.type === "principal") {
         if (resolved.ref.principal.type === "serviceAccount") {
           const actorId = execution.executor.actorId;
-          if (actorId === undefined || resolved.ref.principal.id !== agentServiceAccountId(actorId) || resolved.ref.credential !== undefined) {
+          if (actorId === undefined || resolved.ref.principal.id !== agentServiceAccountId2(actorId) || resolved.ref.credential !== undefined) {
             throw invalidExecutionAuthority(execution.id, "agent authority must reference its managed service account");
           }
         } else if (resolved.ref.credential === undefined) {
@@ -613,7 +613,7 @@ function principalsEqual(left, right) {
   return left?.type === right?.type && left?.id === right?.id;
 }
 function invalidExecutionAuthority(executionId, reason) {
-  return createSixbError("internal.unexpected", `[Sixb] Execution '${executionId}' is incompatible with its authority: ${reason}.`, { details: { executionId, reason } });
+  return createSixbError2("internal.unexpected", `[Sixb] Execution '${executionId}' is incompatible with its authority: ${reason}.`, { details: { executionId, reason } });
 }
 function register(execution, input) {
   assertNonEmpty(input.projectId, "Authorization project id");
@@ -873,7 +873,7 @@ function assertNonEmpty(value, label) {
 }
 
 // src/authorization/errors.ts
-class AuthorizationError extends Error {
+class AuthorizationError2 extends Error {
   grantKey;
   name = "AuthorizationError";
   constructor(grantKey, message) {
@@ -932,58 +932,58 @@ function holds(grants, atom) {
     return grants[atom.kind];
   return grants[atom.kind].has(atom.id);
 }
-function evaluate(authorization, request) {
+function evaluate2(authorization, request) {
   const atoms = atomsFor(request);
   const requirements = atoms.map(atomKey);
   const missing = authorization ? atoms.filter((atom) => !holds(authorization.grants, atom)).map(atomKey) : [];
   return { allowed: missing.length === 0, requirements, missing };
 }
-function isAllowed(authorization, request) {
-  return evaluate(authorization, request).allowed;
+function isAllowed2(authorization, request) {
+  return evaluate2(authorization, request).allowed;
 }
-function assertAuthorized(runtime, request) {
-  const resolved = assertRuntimeAuthorizationBound(runtime);
+function assertAuthorized2(runtime, request) {
+  const resolved = assertRuntimeAuthorizationBound2(runtime);
   if (resolved.type === "delegated") {
-    throw new AuthorizationError(`delegated:${request.kind}`, `[Sixb] Operation '${request.kind}' is not covered by delegated authorization.`);
+    throw new AuthorizationError2(`delegated:${request.kind}`, `[Sixb] Operation '${request.kind}' is not covered by delegated authorization.`);
   }
   const authorization = resolved.type === "principal" ? resolved.context : undefined;
-  const decision = evaluate(authorization, request);
+  const decision = evaluate2(authorization, request);
   if (decision.allowed) {
     return;
   }
-  throw new AuthorizationError(decision.missing[0] ?? request.kind, deniedMessage(authorization, request));
+  throw new AuthorizationError2(decision.missing[0] ?? request.kind, deniedMessage(authorization, request));
 }
-function isRuntimeAllowed(runtime, request) {
+function isRuntimeAllowed2(runtime, request) {
   const authority = resolveRuntimeAuthorizationForProject(runtime);
   if (authority.type === "denied" || authority.type === "delegated")
     return false;
-  return authority.type === "unrestricted" || isAllowed(authority.context, request);
+  return authority.type === "unrestricted" || isAllowed2(authority.context, request);
 }
-function assertRuntimeAuthorizationBound(runtime) {
+function assertRuntimeAuthorizationBound2(runtime) {
   const resolved = resolveRuntimeAuthorizationForProject(runtime);
   if (resolved.type === "denied") {
-    throw new AuthorizationError("runtime:unbound", "[Sixb] Protected operations require a registered execution scope.");
+    throw new AuthorizationError2("runtime:unbound", "[Sixb] Protected operations require a registered execution scope.");
   }
   return resolved;
 }
-function assertCanEdit(runtime, objectTypeId) {
-  assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-  assertAuthorized(runtime, { kind: "object.edit", objectTypeId });
+function assertCanEdit2(runtime, objectTypeId) {
+  assertAuthorized2(runtime, { kind: "object.view", objectTypeId });
+  assertAuthorized2(runtime, { kind: "object.edit", objectTypeId });
 }
-function assertCanAppendTelemetry(runtime, objectTypeId) {
-  assertAuthorized(runtime, { kind: "telemetry.append", objectTypeId });
+function assertCanAppendTelemetry2(runtime, objectTypeId) {
+  assertAuthorized2(runtime, { kind: "telemetry.append", objectTypeId });
 }
-function assertCanManageConnector(runtime, connectorId) {
-  assertAuthorized(runtime, { kind: "connector.manage", connectorId });
+function assertCanManageConnector2(runtime, connectorId) {
+  assertAuthorized2(runtime, { kind: "connector.manage", connectorId });
 }
-function assertPrivileged(runtime, operation) {
-  const resolved = assertRuntimeAuthorizationBound(runtime);
+function assertPrivileged2(runtime, operation) {
+  const resolved = assertRuntimeAuthorizationBound2(runtime);
   if (resolved.type === "unrestricted") {
     return;
   }
-  throw new AuthorizationError(`privileged:${operation}`, `[Sixb] Operation '${operation}' is not covered by scoped authorization grants.`);
+  throw new AuthorizationError2(`privileged:${operation}`, `[Sixb] Operation '${operation}' is not covered by scoped authorization grants.`);
 }
-function assertProviderAccess(runtime, execution, operation) {
+function assertProviderAccess2(runtime, execution, operation) {
   const resolved = resolveExecutionScopeAuthorization(runtime.projectId, {
     execution,
     authorization: runtime.runtimeAuthorization
@@ -994,7 +994,7 @@ function assertProviderAccess(runtime, execution, operation) {
   if (execution.executor.type === "agent") {
     return;
   }
-  throw new AuthorizationError(`privileged:${operation}`, `[Sixb] Operation '${operation}' is not covered by scoped authorization grants.`);
+  throw new AuthorizationError2(`privileged:${operation}`, `[Sixb] Operation '${operation}' is not covered by scoped authorization grants.`);
 }
 function deniedMessage(authorization, request) {
   const principalId = authorization?.principal.id ?? "unknown";
@@ -1030,67 +1030,67 @@ function deniedMessage(authorization, request) {
     case "connector.manage":
       return `[Sixb] Principal '${principalId}' is not allowed to manage connector '${request.connectorId}'.`;
     case "object.query": {
-      const blocked = request.touchedObjectTypeIds.find((objectTypeId) => !isAllowed(authorization, { kind: "object.view", objectTypeId }));
+      const blocked = request.touchedObjectTypeIds.find((objectTypeId) => !isAllowed2(authorization, { kind: "object.view", objectTypeId }));
       return `[Sixb] Principal '${principalId}' is not allowed to view object type '${blocked}'.`;
     }
   }
 }
 
 // src/authorization/application-access.ts
-function isApplicationAccessControlled(roles, audience) {
+function isApplicationAccessControlled2(roles, audience) {
   return roles.some((role) => role.grants["access:application"].has(audience));
 }
-function canAccessApplication(authorization, roles, audience) {
-  return !isApplicationAccessControlled(roles, audience) || isAllowed(authorization, { kind: "application.access", audience });
+function canAccessApplication2(authorization, roles, audience) {
+  return !isApplicationAccessControlled2(roles, audience) || isAllowed2(authorization, { kind: "application.access", audience });
 }
 // src/authorization/event-visibility.ts
-function canViewEvent(authorization, event) {
+function canViewEvent2(authorization, event) {
   if (!authorization) {
     return true;
   }
   switch (event.topic) {
     case "objects":
     case "telemetry":
-      return isAllowed(authorization, {
+      return isAllowed2(authorization, {
         kind: "object.view",
         objectTypeId: event.payload.objectTypeId
       });
     case "links":
-      return isAllowed(authorization, {
+      return isAllowed2(authorization, {
         kind: "object.view",
         objectTypeId: event.payload.sourceTypeId
-      }) && isAllowed(authorization, { kind: "object.view", objectTypeId: event.payload.targetTypeId });
+      }) && isAllowed2(authorization, { kind: "object.view", objectTypeId: event.payload.targetTypeId });
     case "actions": {
-      if (!isAllowed(authorization, { kind: "action.apply", actionId: event.payload.actionId })) {
+      if (!isAllowed2(authorization, { kind: "action.apply", actionId: event.payload.actionId })) {
         return false;
       }
       const subject = event.payload.subject;
-      return subject.kind === "object" ? isAllowed(authorization, { kind: "object.view", objectTypeId: subject.objectTypeId }) : true;
+      return subject.kind === "object" ? isAllowed2(authorization, { kind: "object.view", objectTypeId: subject.objectTypeId }) : true;
     }
     case "workflows":
-      return isAllowed(authorization, {
+      return isAllowed2(authorization, {
         kind: "workflow.run",
         workflowId: event.payload.workflowId
       });
     case "rules":
-      return isAllowed(authorization, {
+      return isAllowed2(authorization, {
         kind: "object.view",
         objectTypeId: event.payload.subject.objectTypeId
       });
     case "syncs":
-      return isAllowed(authorization, {
+      return isAllowed2(authorization, {
         kind: "sync.run",
         syncId: event.payload.syncId
       });
     case "pipelines":
-      return isAllowed(authorization, {
+      return isAllowed2(authorization, {
         kind: "pipeline.run",
         pipelineId: event.payload.pipelineId
       });
     case "schedules":
       return true;
     case "datasets":
-      return isAllowed(authorization, {
+      return isAllowed2(authorization, {
         kind: "dataset.view",
         datasetId: event.payload.datasetId
       });
@@ -1099,7 +1099,7 @@ function canViewEvent(authorization, event) {
   }
 }
 // src/authorization/resolve.ts
-function resolveRoleGrants(role, universe) {
+function resolveRoleGrants2(role, universe) {
   const grants = emptyGrantSets();
   for (const grant of role.grants) {
     if (grant.capability === "run" && grant.target === "agent") {
@@ -1131,7 +1131,7 @@ function expandSelection(selection, universe, into, expand) {
     }
   }
 }
-function resolveAuthorizationContext(input) {
+function resolveAuthorizationContext2(input) {
   const memberGroupIds = new Set(input.groupIds);
   const roleIds = [];
   const grants = emptyGrantSets();
@@ -1158,12 +1158,12 @@ function resolveAuthorizationContext(input) {
   };
 }
 // src/projections/errors.ts
-class ProjectionValidationError extends Error {
+class ProjectionValidationError2 extends Error {
   name = "ProjectionValidationError";
 }
 
 // src/projections/ownership.ts
-function computeProjectionOwnership(projection, ontology) {
+function computeProjectionOwnership2(projection, ontology) {
   if (projection._tag === "ObjectProjectionDefinition") {
     const primaryId = ontology.getPrimaryPropertyId(projection.objectTypeId);
     return freezeOwnership({
@@ -1199,7 +1199,7 @@ function computeProjectionOwnership(projection, ontology) {
     }))
   });
 }
-function validateProjectionOwnership(projections) {
+function validateProjectionOwnership2(projections) {
   const existenceOwners = new Map;
   const propertyOwners = new Map;
   const linkOwners = new Map;
@@ -1224,7 +1224,7 @@ function validateProjectionOwnership(projections) {
 function registerOwner(owners, key, projectionId, description) {
   const existing = owners.get(key);
   if (existing !== undefined) {
-    throw new ProjectionValidationError(`[Sixb] Projection '${projectionId}' overlaps ${description} owned by projection '${existing}'.`);
+    throw new ProjectionValidationError2(`[Sixb] Projection '${projectionId}' overlaps ${description} owned by projection '${existing}'.`);
   }
   owners.set(key, projectionId);
 }
@@ -1243,16 +1243,16 @@ function validatePropertyMapping(objectType, mapping) {
   for (const key of mappingKeys) {
     if (!propertyIds.has(key)) {
       const available = [...propertyIds].sort().join(", ");
-      throw new ProjectionValidationError(`Property '${key}' does not exist on object type '${objectType.id}'. ` + `Available properties: ${available}`);
+      throw new ProjectionValidationError2(`Property '${key}' does not exist on object type '${objectType.id}'. ` + `Available properties: ${available}`);
     }
   }
   const primaryProperties = objectType.properties.filter((p) => p.primary === true);
   if (primaryProperties.length !== 1) {
-    throw new ProjectionValidationError(`Object type '${objectType.id}' must have exactly one primary property, ` + `found ${primaryProperties.length}.`);
+    throw new ProjectionValidationError2(`Object type '${objectType.id}' must have exactly one primary property, ` + `found ${primaryProperties.length}.`);
   }
   const primaryId = primaryProperties[0].id;
   if (!(primaryId in mapping)) {
-    throw new ProjectionValidationError(`Primary property '${primaryId}' of object type '${objectType.id}' ` + `must be included in the property mapping.`);
+    throw new ProjectionValidationError2(`Primary property '${primaryId}' of object type '${objectType.id}' ` + `must be included in the property mapping.`);
   }
 }
 function validateAndLowerLinkMapping(objectType, linkMapping, propertyMapping) {
@@ -1262,35 +1262,35 @@ function validateAndLowerLinkMapping(objectType, linkMapping, propertyMapping) {
   for (const [key, descriptor] of Object.entries(linkMapping)) {
     if (!linkIds.has(key)) {
       const available = [...linkIds].sort().join(", ");
-      throw new ProjectionValidationError(`Link '${key}' does not exist on object type '${objectType.id}'. ` + `Available links: ${available}`);
+      throw new ProjectionValidationError2(`Link '${key}' does not exist on object type '${objectType.id}'. ` + `Available links: ${available}`);
     }
     if (key !== descriptor.linkId) {
-      throw new ProjectionValidationError(`Link mapping key '${key}' does not match descriptor linkId '${descriptor.linkId}'.`);
+      throw new ProjectionValidationError2(`Link mapping key '${key}' does not match descriptor linkId '${descriptor.linkId}'.`);
     }
     const link = linksById.get(key);
     if (Array.isArray(link.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`Link '${key}' on object type '${objectType.id}' has a polymorphic target. ` + `FK projection of polymorphic links is not yet supported.`);
+      throw new ProjectionValidationError2(`Link '${key}' on object type '${objectType.id}' has a polymorphic target. ` + `FK projection of polymorphic links is not yet supported.`);
     }
     if (link.targetObjectTypeId === "*") {
-      throw new ProjectionValidationError(`Link '${key}' on object type '${objectType.id}' has a wildcard target. ` + `FK projection of wildcard links is not supported.`);
+      throw new ProjectionValidationError2(`Link '${key}' on object type '${objectType.id}' has a wildcard target. ` + `FK projection of wildcard links is not supported.`);
     }
     const sourcePropertyId = descriptor.sourcePropertyId;
     const sourceField = descriptor.sourceField;
     if (sourcePropertyId && sourceField) {
-      throw new ProjectionValidationError(`FK link '${key}' must use either sourceProperty or sourceField, not both.`);
+      throw new ProjectionValidationError2(`FK link '${key}' must use either sourceProperty or sourceField, not both.`);
     }
     if (!sourcePropertyId && !sourceField) {
-      throw new ProjectionValidationError(`FK link '${key}' must declare sourceProperty or sourceField.`);
+      throw new ProjectionValidationError2(`FK link '${key}' must declare sourceProperty or sourceField.`);
     }
     if (!sourcePropertyId) {
       continue;
     }
     if (!propertyIds.has(sourcePropertyId)) {
       const available = [...propertyIds].sort().join(", ");
-      throw new ProjectionValidationError(`Source property '${sourcePropertyId}' does not exist on ` + `object type '${objectType.id}'. Available properties: ${available}`);
+      throw new ProjectionValidationError2(`Source property '${sourcePropertyId}' does not exist on ` + `object type '${objectType.id}'. Available properties: ${available}`);
     }
     if (!(sourcePropertyId in propertyMapping)) {
-      throw new ProjectionValidationError(`Source property '${sourcePropertyId}' for link '${key}' ` + `must be included in the property mapping.`);
+      throw new ProjectionValidationError2(`Source property '${sourcePropertyId}' for link '${key}' ` + `must be included in the property mapping.`);
     }
   }
   return Object.fromEntries(Object.entries(linkMapping).map(([linkId, descriptor]) => [
@@ -1305,16 +1305,16 @@ function validateAndLowerLinkMapping(objectType, linkMapping, propertyMapping) {
 }
 function validateLinkProjectionTarget(linkToken) {
   if (Array.isArray(linkToken.targetObjectTypeId)) {
-    throw new ProjectionValidationError(`Link '${linkToken.id}' has a polymorphic target. ` + `Link projection of polymorphic links is not yet supported.`);
+    throw new ProjectionValidationError2(`Link '${linkToken.id}' has a polymorphic target. ` + `Link projection of polymorphic links is not yet supported.`);
   }
   if (linkToken.targetObjectTypeId === "*") {
-    throw new ProjectionValidationError(`Link '${linkToken.id}' has a wildcard target. ` + `Link projection of wildcard links is not supported.`);
+    throw new ProjectionValidationError2(`Link '${linkToken.id}' has a wildcard target. ` + `Link projection of wildcard links is not supported.`);
   }
 }
-function validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, valueTypesById, prefix) {
+function validateTelemetryProjectionFieldMapping2(projection, objectType, datasetColumnNames, valueTypesById, prefix) {
   const mappedProperties = Object.entries(projection.properties);
   if (mappedProperties.length === 0) {
-    throw new ProjectionValidationError(`${prefix}: must map at least one telemetry property`);
+    throw new ProjectionValidationError2(`${prefix}: must map at least one telemetry property`);
   }
   const mappedFields = [
     ["objectId", projection.objectIdField],
@@ -1322,7 +1322,7 @@ function validateTelemetryProjectionFieldMapping(projection, objectType, dataset
   ];
   for (const [fieldRole, columnName] of mappedFields) {
     if (!datasetColumnNames.has(columnName)) {
-      throw new ProjectionValidationError(`${prefix}: ${fieldRole} field "${columnName}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
+      throw new ProjectionValidationError2(`${prefix}: ${fieldRole} field "${columnName}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
     }
   }
   const propertiesById = new Map(objectType.properties.map((property) => [property.id, property]));
@@ -1330,25 +1330,25 @@ function validateTelemetryProjectionFieldMapping(projection, objectType, dataset
   for (const [propertyId, mapping] of mappedProperties) {
     const property = propertiesById.get(propertyId);
     if (!property) {
-      throw new ProjectionValidationError(`${prefix}: unknown property "${propertyId}" on type "${projection.objectTypeId}"`);
+      throw new ProjectionValidationError2(`${prefix}: unknown property "${propertyId}" on type "${projection.objectTypeId}"`);
     }
     if (property.mode !== "telemetry") {
-      throw new ProjectionValidationError(`${prefix}: property "${propertyId}" on type "${projection.objectTypeId}" must be telemetry-enabled`);
+      throw new ProjectionValidationError2(`${prefix}: property "${propertyId}" on type "${projection.objectTypeId}" must be telemetry-enabled`);
     }
     for (const [fieldRole, columnName] of [
       ["value", mapping.valueField],
       ...mapping.unitField !== undefined ? [["unit", mapping.unitField]] : []
     ]) {
       if (!datasetColumnNames.has(columnName)) {
-        throw new ProjectionValidationError(`${prefix}: property "${propertyId}" ${fieldRole} field "${columnName}" references ` + `unknown dataset column on dataset "${projection.datasetId}"`);
+        throw new ProjectionValidationError2(`${prefix}: property "${propertyId}" ${fieldRole} field "${columnName}" references ` + `unknown dataset column on dataset "${projection.datasetId}"`);
       }
     }
-    const semanticType = resolveSemanticType(property, valueTypesById);
+    const semanticType = resolveSemanticType2(property, valueTypesById);
     if (semanticType !== undefined && mapping.unitField === undefined) {
-      throw new ProjectionValidationError(`${prefix}: property "${propertyId}" requires a unit field because it uses semantic type "${semanticType}"`);
+      throw new ProjectionValidationError2(`${prefix}: property "${propertyId}" requires a unit field because it uses semantic type "${semanticType}"`);
     }
     if (semanticType === undefined && mapping.unitField !== undefined) {
-      throw new ProjectionValidationError(`${prefix}: property "${propertyId}" cannot map a unit field because it has no semantic type`);
+      throw new ProjectionValidationError2(`${prefix}: property "${propertyId}" cannot map a unit field because it has no semantic type`);
     }
     resolvedProperties.set(propertyId, property);
   }
@@ -1366,140 +1366,140 @@ function validateProjectionsAtStartup(projections, ontology, datasetsById) {
     const prefix = `Projection "${projection.id}"`;
     const dataset = datasetsById.get(projection.datasetId);
     if (!dataset) {
-      throw new ProjectionValidationError(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
+      throw new ProjectionValidationError2(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
     }
     const objectType = objectTypesById.get(projection.objectTypeId);
     if (!objectType) {
-      throw new ProjectionValidationError(`${prefix}: unknown object type "${projection.objectTypeId}"`);
+      throw new ProjectionValidationError2(`${prefix}: unknown object type "${projection.objectTypeId}"`);
     }
     const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
     const conflictResolution = projection.conflictResolution ?? { strategy: "editsWin" };
     if (conflictResolution.strategy === "mostRecent") {
       const sourceTimestamp = dataset.schema.columns.find((column) => column.name === conflictResolution.sourceTimestamp);
       if (!sourceTimestamp) {
-        throw new ProjectionValidationError(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" references unknown ` + `dataset column on dataset "${projection.datasetId}"`);
+        throw new ProjectionValidationError2(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" references unknown ` + `dataset column on dataset "${projection.datasetId}"`);
       }
       if (sourceTimestamp.type !== "timestamp") {
-        throw new ProjectionValidationError(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" must reference a ` + `timestamp dataset column`);
+        throw new ProjectionValidationError2(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" must reference a ` + `timestamp dataset column`);
       }
       if (sourceTimestamp.nullable === true) {
-        throw new ProjectionValidationError(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" must reference a ` + `non-null timestamp dataset column`);
+        throw new ProjectionValidationError2(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" must reference a ` + `non-null timestamp dataset column`);
       }
     }
     const propertyIds = new Set(objectType.properties.map((p) => p.id));
     for (const [propId, columnName] of Object.entries(projection.properties)) {
       if (!propertyIds.has(propId)) {
-        throw new ProjectionValidationError(`${prefix}: unknown property "${propId}" on type "${projection.objectTypeId}"`);
+        throw new ProjectionValidationError2(`${prefix}: unknown property "${propId}" on type "${projection.objectTypeId}"`);
       }
       if (!datasetColumnNames.has(columnName)) {
-        throw new ProjectionValidationError(`${prefix}: property "${propId}" references unknown dataset column "${columnName}" ` + `on dataset "${projection.datasetId}"`);
+        throw new ProjectionValidationError2(`${prefix}: property "${propId}" references unknown dataset column "${columnName}" ` + `on dataset "${projection.datasetId}"`);
       }
       const property = objectType.properties.find((candidate) => candidate.id === propId);
       if (property?.mode === "telemetry") {
-        throw new ProjectionValidationError(`[Sixb] ${prefix}: source mappings cannot own telemetry property "${projection.objectTypeId}.${propId}"`);
+        throw new ProjectionValidationError2(`[Sixb] ${prefix}: source mappings cannot own telemetry property "${projection.objectTypeId}.${propId}"`);
       }
     }
     const primaryId = primaryByTypeId.get(projection.objectTypeId);
     if (!(primaryId in projection.properties)) {
-      throw new ProjectionValidationError(`${prefix}: primary property "${primaryId}" must be in property mapping`);
+      throw new ProjectionValidationError2(`${prefix}: primary property "${primaryId}" must be in property mapping`);
     }
     const linkIds = new Set(objectType.links.map((l) => l.id));
     for (const [linkId, fk] of Object.entries(projection.links)) {
       if (!linkIds.has(linkId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" references unknown link on type "${projection.objectTypeId}"`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" references unknown link on type "${projection.objectTypeId}"`);
       }
       if (fk.linkId !== linkId) {
-        throw new ProjectionValidationError(`${prefix}: FK link mapping key "${linkId}" does not match descriptor linkId "${fk.linkId}"`);
+        throw new ProjectionValidationError2(`${prefix}: FK link mapping key "${linkId}" does not match descriptor linkId "${fk.linkId}"`);
       }
       const sourcePropertyId = fk.sourcePropertyId;
       const sourceField = fk.sourceField;
       if (sourcePropertyId && sourceField) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" must use either sourcePropertyId or sourceField, not both`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" must use either sourcePropertyId or sourceField, not both`);
       }
       if (!sourcePropertyId && !sourceField) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" must declare sourcePropertyId or sourceField`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" must declare sourcePropertyId or sourceField`);
       }
       if (sourcePropertyId && !propertyIds.has(sourcePropertyId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" source property "${sourcePropertyId}" does not exist on type "${projection.objectTypeId}"`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" source property "${sourcePropertyId}" does not exist on type "${projection.objectTypeId}"`);
       }
       if (sourcePropertyId && !(sourcePropertyId in projection.properties)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" source property "${sourcePropertyId}" must be in property mapping`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" source property "${sourcePropertyId}" must be in property mapping`);
       }
       if (sourceField && !datasetColumnNames.has(sourceField)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" source field "${sourceField}" references unknown dataset column on dataset "${projection.datasetId}"`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" source field "${sourceField}" references unknown dataset column on dataset "${projection.datasetId}"`);
       }
       if (!objectTypesById.has(fk.targetObjectTypeId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" is unknown`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" is unknown`);
       }
       if (!primaryByTypeId.has(fk.targetObjectTypeId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" has no primary property`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" has no primary property`);
       }
       const link = objectType.links.find((candidate) => candidate.id === linkId);
       if (!ontology.isValidLinkTarget(link.targetObjectTypeId, fk.targetObjectTypeId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" is not compatible with its declared target`);
+        throw new ProjectionValidationError2(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" is not compatible with its declared target`);
       }
     }
     validatedObjectProjections.push({
       definition: projection,
       dataset,
-      ownership: computeProjectionOwnership(projection, ontology)
+      ownership: computeProjectionOwnership2(projection, ontology)
     });
   }
   for (const projection of linkProjections) {
     const prefix = `Projection "${projection.id}"`;
     const dataset = datasetsById.get(projection.datasetId);
     if (!dataset) {
-      throw new ProjectionValidationError(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
+      throw new ProjectionValidationError2(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
     }
     if (!objectTypesById.has(projection.sourceObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: unknown source type "${projection.sourceObjectTypeId}"`);
+      throw new ProjectionValidationError2(`${prefix}: unknown source type "${projection.sourceObjectTypeId}"`);
     }
     if (!objectTypesById.has(projection.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: unknown target type "${projection.targetObjectTypeId}"`);
+      throw new ProjectionValidationError2(`${prefix}: unknown target type "${projection.targetObjectTypeId}"`);
     }
     const sourceType = objectTypesById.get(projection.sourceObjectTypeId);
     const link = sourceType.links.find((candidate) => candidate.id === projection.linkId);
     if (!link) {
-      throw new ProjectionValidationError(`${prefix}: link "${projection.linkId}" does not exist on source type "${projection.sourceObjectTypeId}"`);
+      throw new ProjectionValidationError2(`${prefix}: link "${projection.linkId}" does not exist on source type "${projection.sourceObjectTypeId}"`);
     }
     if (!ontology.isValidLinkTarget(link.targetObjectTypeId, projection.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: target type "${projection.targetObjectTypeId}" is not compatible with link "${projection.linkId}"`);
+      throw new ProjectionValidationError2(`${prefix}: target type "${projection.targetObjectTypeId}" is not compatible with link "${projection.linkId}"`);
     }
     const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
     if (!datasetColumnNames.has(projection.sourceField)) {
-      throw new ProjectionValidationError(`${prefix}: source field "${projection.sourceField}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
+      throw new ProjectionValidationError2(`${prefix}: source field "${projection.sourceField}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
     }
     if (!datasetColumnNames.has(projection.targetField)) {
-      throw new ProjectionValidationError(`${prefix}: target field "${projection.targetField}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
+      throw new ProjectionValidationError2(`${prefix}: target field "${projection.targetField}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
     }
     if (!primaryByTypeId.has(projection.sourceObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: source type "${projection.sourceObjectTypeId}" has no primary property`);
+      throw new ProjectionValidationError2(`${prefix}: source type "${projection.sourceObjectTypeId}" has no primary property`);
     }
     if (!primaryByTypeId.has(projection.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: target type "${projection.targetObjectTypeId}" has no primary property`);
+      throw new ProjectionValidationError2(`${prefix}: target type "${projection.targetObjectTypeId}" has no primary property`);
     }
     validatedLinkProjections.push({
       definition: projection,
       dataset,
-      ownership: computeProjectionOwnership(projection, ontology)
+      ownership: computeProjectionOwnership2(projection, ontology)
     });
   }
   for (const projection of telemetryProjections) {
     const prefix = `Projection "${projection.id}"`;
     const dataset = datasetsById.get(projection.datasetId);
     if (!dataset) {
-      throw new ProjectionValidationError(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
+      throw new ProjectionValidationError2(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
     }
     const objectType = objectTypesById.get(projection.objectTypeId);
     if (!objectType) {
-      throw new ProjectionValidationError(`${prefix}: unknown object type "${projection.objectTypeId}"`);
+      throw new ProjectionValidationError2(`${prefix}: unknown object type "${projection.objectTypeId}"`);
     }
     const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
-    validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, ontology.getValueTypesById(), prefix);
+    validateTelemetryProjectionFieldMapping2(projection, objectType, datasetColumnNames, ontology.getValueTypesById(), prefix);
     validatedTelemetryProjections.push({
       definition: projection,
       dataset,
-      ownership: computeProjectionOwnership(projection, ontology)
+      ownership: computeProjectionOwnership2(projection, ontology)
     });
   }
   const validatedProjections = [
@@ -1507,7 +1507,7 @@ function validateProjectionsAtStartup(projections, ontology, datasetsById) {
     ...validatedLinkProjections,
     ...validatedTelemetryProjections
   ];
-  validateProjectionOwnership(validatedProjections);
+  validateProjectionOwnership2(validatedProjections);
   return {
     objectProjections: validatedObjectProjections,
     linkProjections: validatedLinkProjections,
@@ -1518,13 +1518,13 @@ function validateMaterializationOntologyConstraints(ontology) {
   for (const objectType of ontology.getObjectTypesById().values()) {
     for (const property of objectType.properties) {
       if (property.mode === "telemetry" && property.required === true) {
-        throw new ProjectionValidationError(`[Sixb] Telemetry property '${objectType.id}.${property.id}' cannot be required.`);
+        throw new ProjectionValidationError2(`[Sixb] Telemetry property '${objectType.id}.${property.id}' cannot be required.`);
       }
     }
     for (const link of objectType.links) {
       for (const property of link.properties ?? []) {
         if (property.mode === "telemetry") {
-          throw new ProjectionValidationError(`[Sixb] Link property '${objectType.id}.${link.id}.${property.id}' cannot use telemetry mode.`);
+          throw new ProjectionValidationError2(`[Sixb] Link property '${objectType.id}.${link.id}.${property.id}' cannot use telemetry mode.`);
         }
       }
     }
@@ -1534,12 +1534,12 @@ function validateMaterializationOntologyConstraints(ontology) {
 // src/projections/builders.ts
 function assertNonEmpty2(value, field) {
   if (!value.trim()) {
-    throw new ProjectionValidationError(`Projection ${field} must not be empty.`);
+    throw new ProjectionValidationError2(`Projection ${field} must not be empty.`);
   }
 }
 function assertProjectionDataset(dataset) {
   if (!dataset || dataset.kind !== "dataset" || typeof dataset.id !== "string") {
-    throw new ProjectionValidationError("Projection dataset must be a dataset definition.");
+    throw new ProjectionValidationError2("Projection dataset must be a dataset definition.");
   }
   assertNonEmpty2(dataset.id, "dataset id");
 }
@@ -1551,14 +1551,14 @@ function lowerForeignKeyMapping(mapping) {
   for (const [linkId, descriptor] of Object.entries(mapping)) {
     if (!descriptor)
       continue;
-    lowered[linkId] = isForeignKeyDescriptor(descriptor) ? descriptor : fromForeignKey(descriptor);
+    lowered[linkId] = isForeignKeyDescriptor(descriptor) ? descriptor : fromForeignKey2(descriptor);
   }
   return lowered;
 }
 function isForeignKeyDescriptor(value) {
   return isRecord2(value) && typeof value.linkId === "string";
 }
-function defineProjection(id, target) {
+function defineProjection2(id, target) {
   if ("link" in target)
     return buildLinkProjection(id, target);
   if ("property" in target)
@@ -1661,24 +1661,24 @@ function buildTelemetryProjection(id, propertyToken) {
 }
 function validateTelemetryProjectionProperty(propertyToken) {
   if (propertyToken.property.mode !== "telemetry") {
-    throw new ProjectionValidationError(`Projection property '${propertyToken.objectTypeId}.${propertyToken.id}' must be telemetry-enabled.`);
+    throw new ProjectionValidationError2(`Projection property '${propertyToken.objectTypeId}.${propertyToken.id}' must be telemetry-enabled.`);
   }
 }
 function lowerTelemetryPointMapping(mapping) {
   const allowedKeys = new Set(["objectId", "at", "value", "unit"]);
   for (const key of Object.keys(mapping)) {
     if (!allowedKeys.has(key)) {
-      throw new ProjectionValidationError(`Telemetry projection point mapping contains unknown key '${key}'.`);
+      throw new ProjectionValidationError2(`Telemetry projection point mapping contains unknown key '${key}'.`);
     }
   }
   if (mapping.objectId === undefined) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires objectId.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping requires objectId.");
   }
   if (mapping.at === undefined) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires at.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping requires at.");
   }
   if (mapping.value === undefined) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires value.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping requires value.");
   }
   assertNonEmpty2(mapping.objectId, "objectId field");
   assertNonEmpty2(mapping.at, "at field");
@@ -1697,36 +1697,36 @@ function lowerTelemetryPropertiesPointMapping(objectType, mapping) {
   const allowedKeys = new Set(["objectId", "at", "properties"]);
   for (const key of Object.keys(mapping)) {
     if (!allowedKeys.has(key)) {
-      throw new ProjectionValidationError(`Telemetry projection point mapping contains unknown key '${key}'.`);
+      throw new ProjectionValidationError2(`Telemetry projection point mapping contains unknown key '${key}'.`);
     }
   }
   if (mapping.objectId === undefined) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires objectId.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping requires objectId.");
   }
   if (mapping.at === undefined) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires at.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping requires at.");
   }
   if (mapping.properties === undefined) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires properties.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping requires properties.");
   }
   if (!isRecord2(mapping.properties)) {
-    throw new ProjectionValidationError("Telemetry projection point mapping properties must be an object.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping properties must be an object.");
   }
   assertNonEmpty2(mapping.objectId, "objectId field");
   assertNonEmpty2(mapping.at, "at field");
   const propertyEntries = Object.entries(mapping.properties);
   if (propertyEntries.length === 0) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires at least one property.");
+    throw new ProjectionValidationError2("Telemetry projection point mapping requires at least one property.");
   }
   const propertiesById = new Map(objectType.properties.map((property) => [property.id, property]));
   const properties = {};
   for (const [propertyId, input] of propertyEntries) {
     const property = propertiesById.get(propertyId);
     if (!property) {
-      throw new ProjectionValidationError(`Property '${propertyId}' does not exist on object type '${objectType.id}'.`);
+      throw new ProjectionValidationError2(`Property '${propertyId}' does not exist on object type '${objectType.id}'.`);
     }
     if (property.mode !== "telemetry") {
-      throw new ProjectionValidationError(`Projection property '${objectType.id}.${propertyId}' must be telemetry-enabled.`);
+      throw new ProjectionValidationError2(`Projection property '${objectType.id}.${propertyId}' must be telemetry-enabled.`);
     }
     properties[propertyId] = lowerTelemetryPropertyMapping(propertyId, input);
   }
@@ -1738,25 +1738,25 @@ function lowerTelemetryPropertyMapping(propertyId, input) {
     return { valueField: input };
   }
   if (!isRecord2(input)) {
-    throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' must map a value column or value/unit columns.`);
+    throw new ProjectionValidationError2(`Telemetry projection property '${propertyId}' must map a value column or value/unit columns.`);
   }
   const allowedKeys = new Set(["value", "unit"]);
   for (const key of Object.keys(input)) {
     if (!allowedKeys.has(key)) {
-      throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' contains unknown key '${key}'.`);
+      throw new ProjectionValidationError2(`Telemetry projection property '${propertyId}' contains unknown key '${key}'.`);
     }
   }
   if (typeof input.value !== "string") {
-    throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' requires a value field.`);
+    throw new ProjectionValidationError2(`Telemetry projection property '${propertyId}' requires a value field.`);
   }
   if (typeof input.unit !== "string") {
-    throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' requires a unit field.`);
+    throw new ProjectionValidationError2(`Telemetry projection property '${propertyId}' requires a unit field.`);
   }
   assertNonEmpty2(input.value, `property '${propertyId}' value field`);
   assertNonEmpty2(input.unit, `property '${propertyId}' unit field`);
   return { valueField: input.value, unitField: input.unit };
 }
-function fromForeignKey(input) {
+function fromForeignKey2(input) {
   validateLinkProjectionTarget(input.link);
   if (input.sourceProperty) {
     return {
@@ -1766,7 +1766,7 @@ function fromForeignKey(input) {
     };
   }
   if (input.sourceField === undefined) {
-    throw new ProjectionValidationError("Foreign key sourceField is required.");
+    throw new ProjectionValidationError2("Foreign key sourceField is required.");
   }
   assertNonEmpty2(input.sourceField, "source field");
   return {
@@ -1805,7 +1805,7 @@ function buildLinkProjection(id, linkToken) {
     }
   };
 }
-function isObjectProjectionDefinition(value) {
+function isObjectProjectionDefinition2(value) {
   if (!isRecord2(value))
     return false;
   return value._tag === "ObjectProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && isRecord2(value.properties) && isRecord2(value.links) && isSourceEditConflictResolution(value.conflictResolution);
@@ -1819,12 +1819,12 @@ function isSourceEditConflictResolution(value) {
     return value.sourceTimestamp === undefined;
   return value.strategy === "mostRecent" && typeof value.sourceTimestamp === "string";
 }
-function isLinkProjectionDefinition(value) {
+function isLinkProjectionDefinition2(value) {
   if (!isRecord2(value))
     return false;
   return value._tag === "LinkProjectionDefinition" && typeof value.id === "string" && typeof value.linkId === "string" && typeof value.sourceObjectTypeId === "string" && typeof value.targetObjectTypeId === "string" && typeof value.datasetId === "string" && typeof value.sourceField === "string" && typeof value.targetField === "string";
 }
-function isTelemetryProjectionDefinition(value) {
+function isTelemetryProjectionDefinition2(value) {
   if (!isRecord2(value))
     return false;
   return value._tag === "TelemetryProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && typeof value.objectIdField === "string" && typeof value.atField === "string" && isTelemetryProjectionProperties(value.properties);
@@ -1834,10 +1834,10 @@ function isTelemetryProjectionProperties(value) {
     return false;
   return Object.values(value).every((mapping) => isRecord2(mapping) && typeof mapping.valueField === "string" && (mapping.unitField === undefined || typeof mapping.unitField === "string"));
 }
-function isProjectionDefinition(value) {
-  return isObjectProjectionDefinition(value) || isLinkProjectionDefinition(value) || isTelemetryProjectionDefinition(value);
+function isProjectionDefinition2(value) {
+  return isObjectProjectionDefinition2(value) || isLinkProjectionDefinition2(value) || isTelemetryProjectionDefinition2(value);
 }
-function projectionTargetOf(projection) {
+function projectionTargetOf2(projection) {
   return projection._tag === "LinkProjectionDefinition" ? {
     sourceObjectTypeId: projection.sourceObjectTypeId,
     targetObjectTypeId: projection.targetObjectTypeId
@@ -1845,43 +1845,43 @@ function projectionTargetOf(projection) {
 }
 
 // src/authorization/run-visibility.ts
-function canViewActionRun(authorization, run) {
+function canViewActionRun2(authorization, run) {
   if (!authorization) {
     return true;
   }
-  if (!isAllowed(authorization, { kind: "action.apply", actionId: run.actionId })) {
+  if (!isAllowed2(authorization, { kind: "action.apply", actionId: run.actionId })) {
     return false;
   }
-  return run.subject.kind !== "object" ? true : isAllowed(authorization, {
+  return run.subject.kind !== "object" ? true : isAllowed2(authorization, {
     kind: "object.view",
     objectTypeId: run.subject.objectTypeId
   });
 }
-function canViewWorkflowRun(authorization, run) {
-  return !authorization || isAllowed(authorization, { kind: "workflow.run", workflowId: run.workflowId });
+function canViewWorkflowRun2(authorization, run) {
+  return !authorization || isAllowed2(authorization, { kind: "workflow.run", workflowId: run.workflowId });
 }
-function canViewWorkflowIntervention(authorization, intervention) {
-  return !authorization || isAllowed(authorization, { kind: "workflow.run", workflowId: intervention.workflowId });
+function canViewWorkflowIntervention2(authorization, intervention) {
+  return !authorization || isAllowed2(authorization, { kind: "workflow.run", workflowId: intervention.workflowId });
 }
-function canViewPipelineRun(authorization, run) {
-  return !authorization || isAllowed(authorization, { kind: "pipeline.run", pipelineId: run.pipelineId });
+function canViewPipelineRun2(authorization, run) {
+  return !authorization || isAllowed2(authorization, { kind: "pipeline.run", pipelineId: run.pipelineId });
 }
-function canViewProjectionRun(authorization, target) {
+function canViewProjectionRun2(authorization, target) {
   if (!authorization)
     return true;
-  const canView = (objectTypeId) => isAllowed(authorization, { kind: "object.view", objectTypeId });
+  const canView = (objectTypeId) => isAllowed2(authorization, { kind: "object.view", objectTypeId });
   if ("sourceObjectTypeId" in target) {
     return canView(target.sourceObjectTypeId) && canView(target.targetObjectTypeId);
   }
   return canView(target.objectTypeId);
 }
-function canViewProjection(authorization, projection) {
-  return canViewProjectionRun(authorization, projectionTargetOf(projection));
+function canViewProjection2(authorization, projection) {
+  return canViewProjectionRun2(authorization, projectionTargetOf2(projection));
 }
 // src/authorization/types.ts
-function emptyGrantIndex() {
+function emptyGrantIndex2() {
   return emptyGrantSets();
 }
-export { ProjectionValidationError, computeProjectionOwnership, validateProjectionOwnership, validateTelemetryProjectionFieldMapping, validateProjectionsAtStartup, defineProjection, fromForeignKey, isObjectProjectionDefinition, isLinkProjectionDefinition, isTelemetryProjectionDefinition, isProjectionDefinition, projectionTargetOf, agentServiceAccountId, GRANT_KINDS, grantKindOf, MAX_OBJECT_READ_FACETS, ObjectReadLimitExceededError, snapshotObjectReadExecutionLimits, assertObjectReadFacetCount, assertObjectReadOutputWithinLimit, createPrincipalRuntimeAuthorization, createAgentRuntimeAuthorization, createDisabledRuntimeAuthorization, createDelegatedRuntimeAuthorization, createTrustedPrimitiveRuntimeAuthorization, resolveRuntimeAuthorizationForProject, getAuthorizationRef, captureExecutionScope, resolveExecutionScopeAuthorization, AuthorizationError, evaluate, isAllowed, assertAuthorized, isRuntimeAllowed, assertRuntimeAuthorizationBound, assertCanEdit, assertCanAppendTelemetry, assertCanManageConnector, assertPrivileged, assertProviderAccess, isApplicationAccessControlled, canAccessApplication, canViewEvent, resolveRoleGrants, resolveAuthorizationContext, canViewActionRun, canViewWorkflowRun, canViewWorkflowIntervention, canViewPipelineRun, canViewProjectionRun, canViewProjection, emptyGrantIndex };
+export { ProjectionValidationError2, computeProjectionOwnership2, validateProjectionOwnership2, validateTelemetryProjectionFieldMapping2, validateProjectionsAtStartup, defineProjection2, fromForeignKey2, isObjectProjectionDefinition2, isLinkProjectionDefinition2, isTelemetryProjectionDefinition2, isProjectionDefinition2, projectionTargetOf2, agentServiceAccountId2, GRANT_KINDS, grantKindOf, MAX_OBJECT_READ_FACETS2, ObjectReadLimitExceededError2, snapshotObjectReadExecutionLimits2, assertObjectReadFacetCount2, assertObjectReadOutputWithinLimit2, createPrincipalRuntimeAuthorization, createAgentRuntimeAuthorization, createDisabledRuntimeAuthorization, createDelegatedRuntimeAuthorization, createTrustedPrimitiveRuntimeAuthorization, resolveRuntimeAuthorizationForProject, getAuthorizationRef, captureExecutionScope, resolveExecutionScopeAuthorization, AuthorizationError2, evaluate2, isAllowed2, assertAuthorized2, isRuntimeAllowed2, assertRuntimeAuthorizationBound2, assertCanEdit2, assertCanAppendTelemetry2, assertCanManageConnector2, assertPrivileged2, assertProviderAccess2, isApplicationAccessControlled2, canAccessApplication2, canViewEvent2, resolveRoleGrants2, resolveAuthorizationContext2, canViewActionRun2, canViewWorkflowRun2, canViewWorkflowIntervention2, canViewPipelineRun2, canViewProjectionRun2, canViewProjection2, emptyGrantIndex2 };
 
-//# debugId=57388FDEBF4490DF64756E2164756E21
+//# debugId=C7649C713C108F6A64756E2164756E21