@sixb/core 0.0.1

package/dist/chunk-b49dgvsj.js

@@ -0,0 +1,49 @@
+// @bun
+// src/events/scope.ts
+function scopeKeysForEvent(event) {
+  switch (event.topic) {
+    case "objects":
+      return { objectTypeId: event.payload.objectTypeId, primaryId: event.payload.primaryId };
+    case "telemetry":
+      return {
+        objectTypeId: event.payload.objectTypeId,
+        primaryId: event.payload.objectId,
+        propertyId: event.payload.propertyId
+      };
+    case "links":
+      return {
+        objectTypeId: event.payload.sourceTypeId,
+        primaryId: event.payload.sourceId,
+        linkId: event.payload.linkId
+      };
+    case "workflows":
+      return { runId: event.payload.runId };
+    case "pipelines":
+      return { pipelineId: event.payload.pipelineId, runId: event.payload.runId };
+    case "syncs":
+      return { syncId: event.payload.syncId, runId: event.payload.runId };
+    case "actions":
+      return {
+        actionId: event.payload.actionId,
+        runId: event.payload.runId,
+        ...event.payload.subject.kind === "object" ? {
+          objectTypeId: event.payload.subject.objectTypeId,
+          primaryId: event.payload.subject.primaryId
+        } : {}
+      };
+    case "rules":
+      return { ruleId: event.payload.ruleId };
+    case "schedules":
+      return {};
+    case "datasets":
+      return { datasetId: event.payload.datasetId };
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
+  }
+}
+
+export { scopeKeysForEvent };
+
+//# debugId=C3A464604785AE4464756E2164756E21

package/dist/chunk-b49dgvsj.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/events/scope.ts"],
+  "sourcesContent": [
+    "import type { DomainEvent } from \"./types/index\"\n\n/**\n * The scope keys an event can be matched against by a subscription filter.\n *\n * Object identity lives in different payload fields per topic (objects use\n * `objectTypeId`/`primaryId`, telemetry uses `objectId`, links use the source\n * side), so this resolves them topic-aware. It is the single source of truth\n * shared by the client predicate (`buildEventPredicate`) and the server poll\n * filter (`eventMatchesScope`) so the two can never drift — adding a topic is a\n * compile error here until this switch is extended.\n */\nexport interface EventScopeKeys {\n  readonly objectTypeId?: string\n  readonly primaryId?: string\n  readonly propertyId?: string\n  readonly linkId?: string\n  readonly ruleId?: string\n  readonly runId?: string\n  readonly actionId?: string\n  readonly datasetId?: string\n  readonly syncId?: string\n  readonly pipelineId?: string\n}\n\nexport function scopeKeysForEvent(event: DomainEvent): EventScopeKeys {\n  switch (event.topic) {\n    case \"objects\":\n      return { objectTypeId: event.payload.objectTypeId, primaryId: event.payload.primaryId }\n    case \"telemetry\":\n      return {\n        objectTypeId: event.payload.objectTypeId,\n        primaryId: event.payload.objectId,\n        propertyId: event.payload.propertyId,\n      }\n    case \"links\":\n      return {\n        objectTypeId: event.payload.sourceTypeId,\n        primaryId: event.payload.sourceId,\n        linkId: event.payload.linkId,\n      }\n    case \"workflows\":\n      return { runId: event.payload.runId }\n    case \"pipelines\":\n      return { pipelineId: event.payload.pipelineId, runId: event.payload.runId }\n    case \"syncs\":\n      return { syncId: event.payload.syncId, runId: event.payload.runId }\n    case \"actions\":\n      return {\n        actionId: event.payload.actionId,\n        runId: event.payload.runId,\n        ...(event.payload.subject.kind === \"object\"\n          ? {\n              objectTypeId: event.payload.subject.objectTypeId,\n              primaryId: event.payload.subject.primaryId,\n            }\n          : {}),\n      }\n    case \"rules\":\n      return { ruleId: event.payload.ruleId }\n    case \"schedules\":\n      return {}\n    case \"datasets\":\n      return { datasetId: event.payload.datasetId }\n    default: {\n      // Exhaustiveness guard: a new topic must extend the switch above.\n      const _exhaustive: never = event\n      return _exhaustive\n    }\n  }\n}\n"
+  ],
+  "mappings": ";;AAyBO,SAAS,iBAAiB,CAAC,OAAoC;AAAA,EACpE,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,OAAO,EAAE,cAAc,MAAM,QAAQ,cAAc,WAAW,MAAM,QAAQ,UAAU;AAAA,SACnF;AAAA,MACH,OAAO;AAAA,QACL,cAAc,MAAM,QAAQ;AAAA,QAC5B,WAAW,MAAM,QAAQ;AAAA,QACzB,YAAY,MAAM,QAAQ;AAAA,MAC5B;AAAA,SACG;AAAA,MACH,OAAO;AAAA,QACL,cAAc,MAAM,QAAQ;AAAA,QAC5B,WAAW,MAAM,QAAQ;AAAA,QACzB,QAAQ,MAAM,QAAQ;AAAA,MACxB;AAAA,SACG;AAAA,MACH,OAAO,EAAE,OAAO,MAAM,QAAQ,MAAM;AAAA,SACjC;AAAA,MACH,OAAO,EAAE,YAAY,MAAM,QAAQ,YAAY,OAAO,MAAM,QAAQ,MAAM;AAAA,SACvE;AAAA,MACH,OAAO,EAAE,QAAQ,MAAM,QAAQ,QAAQ,OAAO,MAAM,QAAQ,MAAM;AAAA,SAC/D;AAAA,MACH,OAAO;AAAA,QACL,UAAU,MAAM,QAAQ;AAAA,QACxB,OAAO,MAAM,QAAQ;AAAA,WACjB,MAAM,QAAQ,QAAQ,SAAS,WAC/B;AAAA,UACE,cAAc,MAAM,QAAQ,QAAQ;AAAA,UACpC,WAAW,MAAM,QAAQ,QAAQ;AAAA,QACnC,IACA,CAAC;AAAA,MACP;AAAA,SACG;AAAA,MACH,OAAO,EAAE,QAAQ,MAAM,QAAQ,OAAO;AAAA,SACnC;AAAA,MACH,OAAO,CAAC;AAAA,SACL;AAAA,MACH,OAAO,EAAE,WAAW,MAAM,QAAQ,UAAU;AAAA,aACrC;AAAA,MAEP,MAAM,cAAqB;AAAA,MAC3B,OAAO;AAAA,IACT;AAAA;AAAA;",
+  "debugId": "C3A464604785AE4464756E2164756E21",
+  "names": []
+}

package/dist/chunk-btpe64e4.js

@@ -0,0 +1,554 @@
+// @bun
+import {
+  compareStrings
+} from "./chunk-1vffvydj.js";
+
+// src/projections/errors.ts
+class ProjectionValidationError extends Error {
+  name = "ProjectionValidationError";
+}
+
+// src/projections/ownership.ts
+function computeProjectionOwnership(projection, ontology) {
+  if (projection._tag === "ObjectProjectionDefinition") {
+    const primaryId = ontology.getPrimaryPropertyId(projection.objectTypeId);
+    return freezeOwnership({
+      objects: [
+        {
+          objectTypeId: projection.objectTypeId,
+          existence: true,
+          propertyIds: Object.keys(projection.properties).filter((propertyId) => propertyId !== primaryId).sort(compareStrings)
+        }
+      ],
+      links: Object.keys(projection.links).sort(compareStrings).map((linkId) => ({ sourceObjectTypeId: projection.objectTypeId, linkId })),
+      telemetry: []
+    });
+  }
+  if (projection._tag === "LinkProjectionDefinition") {
+    return freezeOwnership({
+      objects: [],
+      links: [
+        {
+          sourceObjectTypeId: projection.sourceObjectTypeId,
+          linkId: projection.linkId
+        }
+      ],
+      telemetry: []
+    });
+  }
+  return freezeOwnership({
+    objects: [],
+    links: [],
+    telemetry: [
+      {
+        objectTypeId: projection.objectTypeId,
+        propertyId: projection.propertyId
+      }
+    ]
+  });
+}
+function validateProjectionOwnership(projections) {
+  const existenceOwners = new Map;
+  const propertyOwners = new Map;
+  const linkOwners = new Map;
+  const telemetryOwners = new Map;
+  for (const { definition, ownership } of projections) {
+    for (const object of ownership.objects) {
+      if (object.existence) {
+        registerOwner(existenceOwners, object.objectTypeId, definition.id, `object type '${object.objectTypeId}' existence`);
+      }
+      for (const propertyId of object.propertyIds) {
+        registerOwner(propertyOwners, JSON.stringify([object.objectTypeId, propertyId]), definition.id, `property '${object.objectTypeId}.${propertyId}'`);
+      }
+    }
+    for (const link of ownership.links) {
+      registerOwner(linkOwners, JSON.stringify([link.sourceObjectTypeId, link.linkId]), definition.id, `link scope '${link.sourceObjectTypeId}.${link.linkId}'`);
+    }
+    for (const telemetry of ownership.telemetry) {
+      registerOwner(telemetryOwners, JSON.stringify([telemetry.objectTypeId, telemetry.propertyId]), definition.id, `telemetry source '${telemetry.objectTypeId}.${telemetry.propertyId}'`);
+    }
+  }
+}
+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}'.`);
+  }
+  owners.set(key, projectionId);
+}
+function freezeOwnership(ownership) {
+  return Object.freeze({
+    objects: Object.freeze(ownership.objects.map((object) => Object.freeze({ ...object, propertyIds: Object.freeze([...object.propertyIds]) }))),
+    links: Object.freeze(ownership.links.map((link) => Object.freeze({ ...link }))),
+    telemetry: Object.freeze(ownership.telemetry.map((telemetry) => Object.freeze({ ...telemetry })))
+  });
+}
+
+// src/projections/validation.ts
+function validatePropertyMapping(objectType, mapping) {
+  const propertyIds = new Set(objectType.properties.map((p) => p.id));
+  const mappingKeys = Object.keys(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}`);
+    }
+  }
+  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}.`);
+  }
+  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.`);
+  }
+}
+function validateAndLowerLinkMapping(objectType, linkMapping, propertyMapping) {
+  const linkIds = new Set(objectType.links.map((l) => l.id));
+  const linksById = new Map(objectType.links.map((l) => [l.id, l]));
+  const propertyIds = new Set(objectType.properties.map((p) => p.id));
+  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}`);
+    }
+    if (key !== descriptor.linkId) {
+      throw new ProjectionValidationError(`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.`);
+    }
+    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.`);
+    }
+    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.`);
+    }
+    if (!sourcePropertyId && !sourceField) {
+      throw new ProjectionValidationError(`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}`);
+    }
+    if (!(sourcePropertyId in propertyMapping)) {
+      throw new ProjectionValidationError(`Source property '${sourcePropertyId}' for link '${key}' ` + `must be included in the property mapping.`);
+    }
+  }
+  return Object.fromEntries(Object.entries(linkMapping).map(([linkId, descriptor]) => [
+    linkId,
+    {
+      linkId: descriptor.linkId,
+      ...descriptor.sourcePropertyId !== undefined ? { sourcePropertyId: descriptor.sourcePropertyId } : {},
+      ...descriptor.sourceField !== undefined ? { sourceField: descriptor.sourceField } : {},
+      targetObjectTypeId: descriptor.targetObjectTypeId
+    }
+  ]));
+}
+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.`);
+  }
+  if (linkToken.targetObjectTypeId === "*") {
+    throw new ProjectionValidationError(`Link '${linkToken.id}' has a wildcard target. ` + `Link projection of wildcard links is not supported.`);
+  }
+}
+function validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, prefix) {
+  const property = objectType.properties.find((candidate) => candidate.id === projection.propertyId);
+  if (!property) {
+    throw new ProjectionValidationError(`${prefix}: unknown property "${projection.propertyId}" on type "${projection.objectTypeId}"`);
+  }
+  if (property.mode !== "telemetry") {
+    throw new ProjectionValidationError(`${prefix}: property "${projection.propertyId}" on type "${projection.objectTypeId}" must be telemetry-enabled`);
+  }
+  const mappedFields = [
+    ["objectId", projection.objectIdField],
+    ["at", projection.atField],
+    ["value", projection.valueField],
+    ...projection.unitField !== undefined ? [["unit", projection.unitField]] : []
+  ];
+  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}"`);
+    }
+  }
+  return property;
+}
+function validateProjectionsAtStartup(projections, ontology, datasetsById) {
+  const { objectProjections, linkProjections, telemetryProjections } = projections;
+  const objectTypesById = ontology.getObjectTypesById();
+  const primaryByTypeId = ontology.getPrimaryByTypeId();
+  const validatedObjectProjections = [];
+  const validatedLinkProjections = [];
+  const validatedTelemetryProjections = [];
+  validateMaterializationOntologyConstraints(ontology);
+  for (const projection of objectProjections) {
+    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/'.`);
+    }
+    const objectType = objectTypesById.get(projection.objectTypeId);
+    if (!objectType) {
+      throw new ProjectionValidationError(`${prefix}: unknown object type "${projection.objectTypeId}"`);
+    }
+    const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
+    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}"`);
+      }
+      if (!datasetColumnNames.has(columnName)) {
+        throw new ProjectionValidationError(`${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}"`);
+      }
+    }
+    const primaryId = primaryByTypeId.get(projection.objectTypeId);
+    if (!(primaryId in projection.properties)) {
+      throw new ProjectionValidationError(`${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}"`);
+      }
+      if (fk.linkId !== linkId) {
+        throw new ProjectionValidationError(`${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`);
+      }
+      if (!sourcePropertyId && !sourceField) {
+        throw new ProjectionValidationError(`${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}"`);
+      }
+      if (sourcePropertyId && !(sourcePropertyId in projection.properties)) {
+        throw new ProjectionValidationError(`${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}"`);
+      }
+      if (!objectTypesById.has(fk.targetObjectTypeId)) {
+        throw new ProjectionValidationError(`${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`);
+      }
+      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`);
+      }
+    }
+    validatedObjectProjections.push({
+      definition: projection,
+      dataset,
+      ownership: computeProjectionOwnership(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/'.`);
+    }
+    if (!objectTypesById.has(projection.sourceObjectTypeId)) {
+      throw new ProjectionValidationError(`${prefix}: unknown source type "${projection.sourceObjectTypeId}"`);
+    }
+    if (!objectTypesById.has(projection.targetObjectTypeId)) {
+      throw new ProjectionValidationError(`${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}"`);
+    }
+    if (!ontology.isValidLinkTarget(link.targetObjectTypeId, projection.targetObjectTypeId)) {
+      throw new ProjectionValidationError(`${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}"`);
+    }
+    if (!datasetColumnNames.has(projection.targetField)) {
+      throw new ProjectionValidationError(`${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`);
+    }
+    if (!primaryByTypeId.has(projection.targetObjectTypeId)) {
+      throw new ProjectionValidationError(`${prefix}: target type "${projection.targetObjectTypeId}" has no primary property`);
+    }
+    validatedLinkProjections.push({
+      definition: projection,
+      dataset,
+      ownership: computeProjectionOwnership(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/'.`);
+    }
+    const objectType = objectTypesById.get(projection.objectTypeId);
+    if (!objectType) {
+      throw new ProjectionValidationError(`${prefix}: unknown object type "${projection.objectTypeId}"`);
+    }
+    const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
+    validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, prefix);
+    validatedTelemetryProjections.push({
+      definition: projection,
+      dataset,
+      ownership: computeProjectionOwnership(projection, ontology)
+    });
+  }
+  const validatedProjections = [
+    ...validatedObjectProjections,
+    ...validatedLinkProjections,
+    ...validatedTelemetryProjections
+  ];
+  validateProjectionOwnership(validatedProjections);
+  return {
+    objectProjections: validatedObjectProjections,
+    linkProjections: validatedLinkProjections,
+    telemetryProjections: validatedTelemetryProjections
+  };
+}
+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.`);
+      }
+    }
+    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.`);
+        }
+      }
+    }
+  }
+}
+
+// src/projections/builders.ts
+function assertNonEmpty(value, field) {
+  if (!value.trim()) {
+    throw new ProjectionValidationError(`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.");
+  }
+  assertNonEmpty(dataset.id, "dataset id");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function lowerForeignKeyMapping(mapping) {
+  const lowered = {};
+  for (const [linkId, descriptor] of Object.entries(mapping)) {
+    if (!descriptor)
+      continue;
+    lowered[linkId] = isForeignKeyDescriptor(descriptor) ? descriptor : fromForeignKey(descriptor);
+  }
+  return lowered;
+}
+function isForeignKeyDescriptor(value) {
+  return isRecord(value) && typeof value.linkId === "string";
+}
+function defineProjection(id, target) {
+  if ("link" in target)
+    return buildLinkProjection(id, target);
+  if ("property" in target)
+    return buildTelemetryProjection(id, target);
+  return buildObjectProjection(id, target);
+}
+function buildObjectProjection(id, objectType) {
+  assertNonEmpty(id, "id");
+  return {
+    fromDataset(dataset) {
+      assertProjectionDataset(dataset);
+      const datasetId = dataset.id;
+      return {
+        properties(mapping) {
+          const propertyMapping = mapping;
+          validatePropertyMapping(objectType, propertyMapping);
+          const definition = {
+            _tag: "ObjectProjectionDefinition",
+            id,
+            objectTypeId: objectType.id,
+            datasetId,
+            properties: { ...propertyMapping },
+            links: {}
+          };
+          return Object.assign(definition, {
+            withLinks(linkMapping) {
+              const loweredLinkMapping = lowerForeignKeyMapping(linkMapping);
+              const validatedLinks = validateAndLowerLinkMapping(objectType, loweredLinkMapping, propertyMapping);
+              return {
+                _tag: "ObjectProjectionDefinition",
+                id,
+                objectTypeId: objectType.id,
+                datasetId,
+                properties: { ...propertyMapping },
+                links: validatedLinks
+              };
+            }
+          });
+        }
+      };
+    }
+  };
+}
+function buildTelemetryProjection(id, propertyToken) {
+  assertNonEmpty(id, "id");
+  validateTelemetryProjectionProperty(propertyToken);
+  return {
+    fromDataset(dataset) {
+      assertProjectionDataset(dataset);
+      const datasetId = dataset.id;
+      return {
+        points(mapping) {
+          const pointMapping = lowerTelemetryPointMapping(mapping);
+          return {
+            _tag: "TelemetryProjectionDefinition",
+            id,
+            objectTypeId: propertyToken.objectTypeId,
+            propertyId: propertyToken.id,
+            datasetId,
+            objectIdField: pointMapping.objectId,
+            atField: pointMapping.at,
+            valueField: pointMapping.value,
+            ...pointMapping.unit !== undefined ? { unitField: pointMapping.unit } : {}
+          };
+        }
+      };
+    }
+  };
+}
+function validateTelemetryProjectionProperty(propertyToken) {
+  if (propertyToken.property.mode !== "telemetry") {
+    throw new ProjectionValidationError(`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}'.`);
+    }
+  }
+  if (mapping.objectId === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires objectId.");
+  }
+  if (mapping.at === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires at.");
+  }
+  if (mapping.value === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires value.");
+  }
+  assertNonEmpty(mapping.objectId, "objectId field");
+  assertNonEmpty(mapping.at, "at field");
+  assertNonEmpty(mapping.value, "value field");
+  if (mapping.unit !== undefined) {
+    assertNonEmpty(mapping.unit, "unit field");
+  }
+  return {
+    objectId: mapping.objectId,
+    at: mapping.at,
+    value: mapping.value,
+    ...mapping.unit !== undefined ? { unit: mapping.unit } : {}
+  };
+}
+function fromForeignKey(input) {
+  validateLinkProjectionTarget(input.link);
+  if (input.sourceProperty) {
+    return {
+      linkId: input.link.id,
+      sourcePropertyId: input.sourceProperty.id,
+      targetObjectTypeId: input.target.id
+    };
+  }
+  if (input.sourceField === undefined) {
+    throw new ProjectionValidationError("Foreign key sourceField is required.");
+  }
+  assertNonEmpty(input.sourceField, "source field");
+  return {
+    linkId: input.link.id,
+    sourceField: input.sourceField,
+    targetObjectTypeId: input.target.id
+  };
+}
+function buildLinkProjection(id, linkToken) {
+  assertNonEmpty(id, "id");
+  validateLinkProjectionTarget(linkToken);
+  return {
+    fromDataset(dataset) {
+      assertProjectionDataset(dataset);
+      const datasetId = dataset.id;
+      return {
+        sourceField(columnName) {
+          assertNonEmpty(columnName, "source field");
+          return {
+            targetField(targetColumnName) {
+              assertNonEmpty(targetColumnName, "target field");
+              return {
+                _tag: "LinkProjectionDefinition",
+                id,
+                linkId: linkToken.id,
+                sourceObjectTypeId: linkToken.objectTypeId,
+                targetObjectTypeId: linkToken.targetObjectTypeId,
+                datasetId,
+                sourceField: columnName,
+                targetField: targetColumnName
+              };
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function isObjectProjectionDefinition(value) {
+  if (!isRecord(value))
+    return false;
+  return value._tag === "ObjectProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && isRecord(value.properties) && isRecord(value.links);
+}
+function isLinkProjectionDefinition(value) {
+  if (!isRecord(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) {
+  if (!isRecord(value))
+    return false;
+  return value._tag === "TelemetryProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.propertyId === "string" && typeof value.datasetId === "string" && typeof value.objectIdField === "string" && typeof value.atField === "string" && typeof value.valueField === "string" && (value.unitField === undefined || typeof value.unitField === "string");
+}
+function isProjectionDefinition(value) {
+  return isObjectProjectionDefinition(value) || isLinkProjectionDefinition(value) || isTelemetryProjectionDefinition(value);
+}
+function projectionTargetOf(projection) {
+  return projection._tag === "LinkProjectionDefinition" ? {
+    sourceObjectTypeId: projection.sourceObjectTypeId,
+    targetObjectTypeId: projection.targetObjectTypeId
+  } : { objectTypeId: projection.objectTypeId };
+}
+
+export { ProjectionValidationError, computeProjectionOwnership, validateProjectionOwnership, validateTelemetryProjectionFieldMapping, validateProjectionsAtStartup, defineProjection, fromForeignKey, isObjectProjectionDefinition, isLinkProjectionDefinition, isTelemetryProjectionDefinition, isProjectionDefinition, projectionTargetOf };
+
+//# debugId=92806BDDE8D60B1764756E2164756E21