@sixb/core 0.0.1

package/dist/chunk-pv1yad91.js

@@ -0,0 +1,1165 @@
+// @bun
+import {
+  isWorkflowDefinition
+} from "./chunk-0psb6kdw.js";
+import {
+  allPredicates,
+  anyPredicates,
+  assertPredicateShape,
+  createLinkPredicateBuilder,
+  createPropertyPredicateBuilder,
+  isScheduleDefinition,
+  isScheduleReference,
+  notPredicate
+} from "./chunk-867jxh7c.js";
+import {
+  RuntimeError
+} from "./chunk-k6j72mtt.js";
+import {
+  DatasetValidationError,
+  assertDatasetColumnDefinition,
+  assertDatasetDefinition,
+  isDatasetDefinition
+} from "./chunk-r65yscvk.js";
+import {
+  isActionDefinition
+} from "./chunk-jdwx7vzs.js";
+import {
+  isAgentDefinition
+} from "./chunk-nvamz5dv.js";
+import {
+  isGroupDefinition,
+  isMembershipPolicyDefinition,
+  isRoleDefinition
+} from "./chunk-dcgrzj1t.js";
+import {
+  assertAuthorized
+} from "./chunk-0fygrz37.js";
+import {
+  isProjectionDefinition
+} from "./chunk-btpe64e4.js";
+
+// src/bootstrap/discovery.ts
+import { readdir } from "fs/promises";
+import { join, relative } from "path";
+import { pathToFileURL } from "url";
+
+// src/connectors/errors.ts
+class ConnectorError extends Error {
+  name = "ConnectorError";
+}
+
+class ConnectorNotFoundError extends ConnectorError {
+  connectorId;
+  name = "ConnectorNotFoundError";
+  constructor(connectorId) {
+    super(`Unknown connector '${connectorId}'`);
+    this.connectorId = connectorId;
+  }
+}
+
+// src/connectors/builders.ts
+function assertNonEmpty(value, field) {
+  if (!value.trim()) {
+    throw new ConnectorError(`Connector ${field} must not be empty.`);
+  }
+}
+function defineConnector(id, adapter) {
+  assertNonEmpty(id, "id");
+  assertNonEmpty(adapter.type, "type");
+  if (typeof adapter.connect !== "function") {
+    throw new ConnectorError("Connector adapter connect must be a function.");
+  }
+  return {
+    kind: "connector",
+    id,
+    adapter
+  };
+}
+// src/connectors/types.ts
+function isConnectorDefinition(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.kind === "connector" && typeof value.id === "string" && isRecord(value.adapter) && typeof value.adapter.type === "string" && typeof value.adapter.connect === "function";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/datasets/builders.ts
+function col(name, type, options) {
+  const column = {
+    name,
+    type,
+    ...options?.nullable !== undefined ? { nullable: options.nullable } : {}
+  };
+  assertDatasetColumnDefinition(column, (message) => new DatasetValidationError(message));
+  return column;
+}
+function assertDatasetId(id) {
+  if (!id.trim()) {
+    throw new DatasetValidationError("Dataset id must not be empty.");
+  }
+}
+function createDatasetDefinition(id, options) {
+  const definition = {
+    kind: "dataset",
+    id,
+    schema: {
+      columns: [...options.schema]
+    },
+    ...options.partitionBy !== undefined ? { partitionBy: [...options.partitionBy] } : {},
+    ...options.description !== undefined ? { description: options.description } : {}
+  };
+  assertDatasetDefinition(definition, (message) => new DatasetValidationError(message));
+  return definition;
+}
+function assertStringArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new DatasetValidationError(`${field} must be an array of column names.`);
+  }
+  for (const item of value) {
+    if (typeof item !== "string" || !item.trim()) {
+      throw new DatasetValidationError(`${field} must contain only non-empty column names.`);
+    }
+  }
+}
+function deriveDatasetDefinition(id, parent, options = {}) {
+  assertDatasetDefinition(parent, (message) => new DatasetValidationError(message));
+  if (options.pick !== undefined) {
+    assertStringArray(options.pick, "Dataset derive pick");
+  }
+  if (options.add !== undefined && !Array.isArray(options.add)) {
+    throw new DatasetValidationError("Dataset derive add must be an array of columns.");
+  }
+  const parentColumnsByName = new Map(parent.schema.columns.map((column) => [column.name, column]));
+  const pickedColumns = options.pick === undefined ? parent.schema.columns : options.pick.map((columnName) => {
+    const column = parentColumnsByName.get(columnName);
+    if (column === undefined) {
+      throw new DatasetValidationError(`Dataset derive pick column '${columnName}' is not declared on parent dataset '${parent.id}'.`);
+    }
+    return column;
+  });
+  return createDatasetDefinition(id, {
+    schema: [...pickedColumns, ...options.add ?? []],
+    ...options.partitionBy !== undefined ? { partitionBy: options.partitionBy } : {},
+    ...options.description !== undefined ? { description: options.description } : {}
+  });
+}
+function createDatasetDeriveBuilder(id) {
+  assertDatasetId(id);
+  function derive(parent, options) {
+    return deriveDatasetDefinition(id, parent, options);
+  }
+  return { derive };
+}
+function defineDataset(id, options) {
+  if (options === undefined) {
+    return createDatasetDeriveBuilder(id);
+  }
+  return createDatasetDefinition(id, options);
+}
+// src/lake-storage/sql-transforms.ts
+var SQL_DIALECT = {
+  duckdb: "duckdb"
+};
+var SQL_DIALECTS = Object.values(SQL_DIALECT);
+function isSqlDialect(value) {
+  return typeof value === "string" && SQL_DIALECTS.includes(value);
+}
+
+// src/pipelines/errors.ts
+class PipelineError extends Error {
+  name = "PipelineError";
+}
+
+// src/pipelines/builders.ts
+function assertNonEmpty2(value, field) {
+  if (!value.trim()) {
+    throw new PipelineError(`Pipeline ${field} must not be empty.`);
+  }
+}
+function assertDataset(dataset, field) {
+  assertNonEmpty2(dataset.id, field);
+}
+function assertDatasetWriteMode(mode) {
+  if (mode !== "snapshot" && mode !== "append") {
+    throw new PipelineError(`Pipeline step output mode '${mode}' is not supported.`);
+  }
+}
+function assertInputs(inputs) {
+  const entries = Object.entries(inputs);
+  if (entries.length === 0) {
+    throw new PipelineError("Pipeline step input dataset must contain at least one entry.");
+  }
+  for (const [name, dataset] of entries) {
+    assertNonEmpty2(name, "step input name");
+    assertDataset(dataset, "step input dataset");
+  }
+}
+function scheduleReference(schedule) {
+  if (!isScheduleDefinition(schedule)) {
+    throw new PipelineError("Pipeline .when(...) only accepts schedules.");
+  }
+  return { type: "schedule", scheduleId: schedule.id };
+}
+function createPipelineBuilder(definition) {
+  return {
+    ...definition,
+    when(schedule) {
+      return createPipelineBuilder({
+        ...definition,
+        triggers: [...definition.triggers, scheduleReference(schedule)]
+      });
+    },
+    then(step) {
+      const graph = {
+        kind: "sequence",
+        nodes: [...definition.graph.nodes, { kind: "step", step }]
+      };
+      return createPipelineBuilder({
+        ...definition,
+        graph
+      });
+    }
+  };
+}
+function definePipelineStep(id) {
+  assertNonEmpty2(id, "step id");
+  return {
+    inputs(inputs) {
+      assertInputs(inputs);
+      return {
+        output(dataset, options = {}) {
+          assertDataset(dataset, "step output dataset");
+          const mode = options.mode ?? "snapshot";
+          assertDatasetWriteMode(mode);
+          return {
+            run(handler) {
+              return {
+                kind: "pipeline.step",
+                id,
+                inputs,
+                output: dataset,
+                mode,
+                executor: {
+                  kind: "run",
+                  handler
+                }
+              };
+            },
+            sql(sql) {
+              return {
+                kind: "pipeline.step",
+                id,
+                inputs,
+                output: dataset,
+                mode,
+                executor: {
+                  kind: "sql",
+                  dialect: SQL_DIALECT.duckdb,
+                  sql
+                }
+              };
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function definePipeline(id) {
+  assertNonEmpty2(id, "id");
+  return createPipelineBuilder({
+    kind: "pipeline",
+    id,
+    triggers: [],
+    graph: {
+      kind: "sequence",
+      nodes: []
+    }
+  });
+}
+// src/pipelines/request.ts
+import { randomUUID } from "crypto";
+async function requestPipelineRun(runtime, pipeline, options = {}) {
+  assertAuthorized(runtime, { kind: "pipeline.run", pipelineId: pipeline.id });
+  if (!runtime.storage.pipelineRuns) {
+    throw new PipelineError("[Sixb] Pipeline run storage is not configured.");
+  }
+  const queue = runtime.queues.pipelines;
+  if (!queue) {
+    throw new PipelineError("[Sixb] Pipeline run queue is not configured.");
+  }
+  const runId = createPipelineRunId(options.runId);
+  const queuedAt = new Date().toISOString();
+  const [job] = await queue.enqueue({
+    projectId: runtime.projectId,
+    jobs: [{ type: "pipeline.run.requested", payload: { pipelineId: pipeline.id, runId } }]
+  });
+  return { pipelineId: pipeline.id, runId, queuedAt, jobId: job?.id };
+}
+function createPipelineRunId(runId) {
+  if (runId !== undefined) {
+    if (!runId.trim()) {
+      throw new PipelineError("[Sixb] Pipeline run id must not be empty");
+    }
+    return runId;
+  }
+  return `run_${randomUUID()}`;
+}
+// src/pipelines/types.ts
+function isPipelineDefinition(value) {
+  if (!isRecord2(value))
+    return false;
+  return value.kind === "pipeline" && typeof value.id === "string" && Array.isArray(value.triggers) && value.triggers.every(isScheduleReference) && isPipelineGraph(value.graph);
+}
+function isPipelineStepDefinition(value) {
+  return isRecord2(value) && value.kind === "pipeline.step" && typeof value.id === "string" && isInputsRecord(value.inputs) && isDatasetDefinition(value.output) && isDatasetWriteMode(value.mode) && isPipelineStepExecutor(value.executor);
+}
+function isPipelineGraph(value) {
+  return isRecord2(value) && value.kind === "sequence" && Array.isArray(value.nodes) && value.nodes.every((node) => isRecord2(node) && node.kind === "step" && isPipelineStepDefinition(node.step));
+}
+function isPipelineStepExecutor(value) {
+  if (!isRecord2(value))
+    return false;
+  switch (value.kind) {
+    case "sql":
+      return isSqlDialect(value.dialect) && typeof value.sql === "function";
+    case "run":
+      return typeof value.handler === "function";
+    default:
+      return false;
+  }
+}
+function isInputsRecord(value) {
+  return isRecord2(value) && Object.entries(value).every(([key, dataset]) => key.trim().length > 0 && isDatasetDefinition(dataset));
+}
+function isDatasetWriteMode(value) {
+  return value === "snapshot" || value === "append";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/rules/errors.ts
+class RuleError extends Error {
+  name = "RuleError";
+}
+
+class RuleValidationError extends RuleError {
+  name = "RuleValidationError";
+}
+
+// src/rules/validation.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertNonEmptyString(value, field, createError) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw createError(`${field} must not be empty.`);
+  }
+}
+function assertRulePredicateShape(value, createError = (message) => new RuleValidationError(message)) {
+  assertPredicateShape(value, { subject: "Rule", createError });
+}
+function assertRuleDefinition(value, createError = (message) => new RuleValidationError(message)) {
+  if (!isRecord3(value)) {
+    throw createError("Rule definition must be an object.");
+  }
+  if (value.kind !== "rule") {
+    throw createError("Rule definition kind must be 'rule'.");
+  }
+  assertNonEmptyString(value.id, "Rule id", createError);
+  if (!isRecord3(value.subject) || value.subject.kind !== "object") {
+    throw createError(`Rule '${value.id}' subject must be an object subject.`);
+  }
+  assertNonEmptyString(value.subject.objectTypeId, `Rule '${value.id}' subject objectTypeId`, createError);
+  assertRulePredicateShape(value.predicate, createError);
+}
+function isRuleDefinition(value) {
+  try {
+    assertRuleDefinition(value, (message) => new Error(message));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateRulesAtStartup(rules, ontology) {
+  const seenRuleIds = new Set;
+  for (const rule of rules) {
+    assertRuleDefinition(rule);
+    if (seenRuleIds.has(rule.id)) {
+      throw new RuleValidationError(`Duplicate rule id: ${rule.id}`);
+    }
+    seenRuleIds.add(rule.id);
+    const objectType = ontology.getObjectTypeById(rule.subject.objectTypeId);
+    if (!objectType) {
+      throw new RuleValidationError(`Rule "${rule.id}": unknown object type "${rule.subject.objectTypeId}".`);
+    }
+    validatePredicateAgainstSubject(rule, objectType, rule.predicate);
+  }
+}
+function validatePredicateAgainstSubject(rule, objectType, predicate) {
+  if (predicate.kind === "all" || predicate.kind === "any") {
+    if (predicate.predicates.length === 0) {
+      throw new RuleValidationError(`Rule "${rule.id}": ${predicate.kind} predicate must contain at least one predicate.`);
+    }
+    for (const child of predicate.predicates) {
+      validatePredicateAgainstSubject(rule, objectType, child);
+    }
+    return;
+  }
+  if (predicate.kind === "not") {
+    validatePredicateAgainstSubject(rule, objectType, predicate.predicate);
+    return;
+  }
+  if (predicate.kind === "property") {
+    const propertyIds = new Set(objectType.properties.map((property) => property.id));
+    if (!propertyIds.has(predicate.propertyId)) {
+      throw new RuleValidationError(`Rule "${rule.id}": unknown property "${predicate.propertyId}" on object type "${objectType.id}".`);
+    }
+    return;
+  }
+  if (predicate.kind === "field") {
+    throw new RuleValidationError(`Rule "${rule.id}": field predicates are not supported in rule conditions.`);
+  }
+  const linkIds = new Set(objectType.links.map((link) => link.id));
+  if (!linkIds.has(predicate.linkId)) {
+    throw new RuleValidationError(`Rule "${rule.id}": unknown link "${predicate.linkId}" on object type "${objectType.id}".`);
+  }
+}
+
+// src/rules/builders.ts
+function assertNonEmpty3(value, field) {
+  if (!value.trim()) {
+    throw new RuleValidationError(`Rule ${field} must not be empty.`);
+  }
+}
+function createPropertyPredicateBuilder2(propertyId) {
+  return createPropertyPredicateBuilder(propertyId, {
+    subject: "Rule",
+    createError: (message) => new RuleValidationError(message)
+  });
+}
+function createLinkPredicateBuilder2(linkId) {
+  return createLinkPredicateBuilder(linkId);
+}
+function createRuleSubjectBuilder(objectType) {
+  const properties = Object.fromEntries(objectType.properties.map((property) => [
+    property.id,
+    createPropertyPredicateBuilder2(property.id)
+  ]));
+  const links = Object.fromEntries(objectType.links.map((link) => [link.id, createLinkPredicateBuilder2(link.id)]));
+  return {
+    p: properties,
+    l: links,
+    all(...predicates) {
+      return allPredicates(predicates);
+    },
+    any(...predicates) {
+      return anyPredicates(predicates);
+    },
+    not(predicate) {
+      return notPredicate(predicate);
+    }
+  };
+}
+function defineRule(id) {
+  assertNonEmpty3(id, "id");
+  const builder = {
+    on(objectType) {
+      return {
+        where(callback) {
+          const predicate = callback(createRuleSubjectBuilder(objectType));
+          assertRulePredicateShape(predicate);
+          return {
+            kind: "rule",
+            id,
+            subject: {
+              kind: "object",
+              objectTypeId: objectType.id
+            },
+            predicate
+          };
+        }
+      };
+    }
+  };
+  return builder;
+}
+// src/syncs/errors.ts
+class SyncValidationError extends Error {
+  name = "SyncValidationError";
+}
+
+// src/syncs/builders.ts
+function assertNonEmpty4(value, field) {
+  if (!value.trim()) {
+    throw new SyncValidationError(`Sync ${field} must not be empty.`);
+  }
+}
+function assertDataset2(dataset) {
+  assertNonEmpty4(dataset.id, "dataset id");
+}
+function normalizeBatchSyncConfig(options) {
+  const mode = options?.mode ?? "snapshot";
+  if (mode !== "snapshot" && mode !== "append") {
+    throw new SyncValidationError(`Invalid sync mode '${String(mode)}'. Expected 'snapshot' or 'append'.`);
+  }
+  return {
+    kind: "batch",
+    mode
+  };
+}
+function defineSync(id, options) {
+  assertNonEmpty4(id, "id");
+  const config = normalizeBatchSyncConfig(options);
+  const triggers = [];
+  function createBuilder() {
+    const builder = {
+      when(schedule) {
+        if (!isScheduleDefinition(schedule)) {
+          throw new SyncValidationError("Sync .when(...) only accepts schedules.");
+        }
+        triggers.push({ type: "schedule", scheduleId: schedule.id });
+        return builder;
+      },
+      checkpoint() {
+        return createBuilder();
+      },
+      from(connector) {
+        return {
+          read(handler) {
+            return {
+              intoDataset(dataset) {
+                assertDataset2(dataset);
+                return {
+                  kind: "sync",
+                  id,
+                  config,
+                  triggers,
+                  connector,
+                  read: handler,
+                  target: {
+                    kind: "dataset",
+                    dataset
+                  }
+                };
+              }
+            };
+          }
+        };
+      }
+    };
+    return builder;
+  }
+  return createBuilder();
+}
+// src/syncs/request.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function requestSyncRun(runtime, sync, options = {}) {
+  assertAuthorized(runtime, { kind: "sync.run", syncId: sync.id });
+  if (!runtime.storage.syncRuns) {
+    throw new SyncValidationError("[Sixb] Sync run storage is not configured.");
+  }
+  const queue = runtime.queues.syncRuns;
+  if (!queue) {
+    throw new SyncValidationError("[Sixb] Sync run queue is not configured.");
+  }
+  const runId = createSyncRunId(options.runId);
+  const queuedAt = new Date().toISOString();
+  const [job] = await queue.enqueue({
+    projectId: runtime.projectId,
+    jobs: [
+      {
+        type: "sync.run.requested",
+        payload: {
+          syncId: sync.id,
+          runId,
+          expectedLatestVersionId: options.expectedLatestVersionId,
+          commitMessage: options.commitMessage
+        }
+      }
+    ]
+  });
+  return { syncId: sync.id, runId, queuedAt, jobId: job?.id };
+}
+function createSyncRunId(runId) {
+  if (runId !== undefined) {
+    if (!runId.trim()) {
+      throw new SyncValidationError("[Sixb] Sync run id must not be empty");
+    }
+    return runId;
+  }
+  return `run_${randomUUID2()}`;
+}
+// src/syncs/types.ts
+function isSyncDefinition(value) {
+  if (!isRecord4(value)) {
+    return false;
+  }
+  return value.kind === "sync" && typeof value.id === "string" && isRecord4(value.config) && value.config.kind === "batch" && (value.config.mode === "snapshot" || value.config.mode === "append") && Array.isArray(value.triggers) && value.triggers.every((reference) => isScheduleReference(reference)) && isConnectorDefinition(value.connector) && typeof value.read === "function" && isRecord4(value.target) && value.target.kind === "dataset" && isDatasetDefinition(value.target.dataset);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/bootstrap/discovery.ts
+var moduleExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+async function discoverOntologySources(projectRoot) {
+  const ontologyDir = join(projectRoot, "ontology");
+  const modulePaths = await listModuleFiles(ontologyDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "ontology"
+  });
+  const ontologyDocuments = [];
+  const objectTypes = [];
+  const valueTypes = [];
+  for (const candidate of exportedCandidates) {
+    if (isOntologyDocumentInput(candidate)) {
+      ontologyDocuments.push(candidate);
+      continue;
+    }
+    if (isObjectTypeWithPropertyTokens(candidate)) {
+      objectTypes.push(candidate);
+      continue;
+    }
+    if (isValueType(candidate)) {
+      valueTypes.push(candidate);
+    }
+  }
+  const discoveredSources = [...ontologyDocuments, ...objectTypes];
+  if (valueTypes.length > 0) {
+    discoveredSources.push({
+      id: "__sixb.discovered.value-types__",
+      version: "0.0.0",
+      objectTypes: [],
+      valueTypes
+    });
+  }
+  return discoveredSources;
+}
+async function discoverActions(projectRoot) {
+  const actionsDir = join(projectRoot, "actions");
+  const modulePaths = await listModuleFiles(actionsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "action"
+  });
+  const actions = [];
+  for (const candidate of exportedCandidates) {
+    if (isActionDefinition(candidate)) {
+      actions.push(candidate);
+    }
+  }
+  return actions;
+}
+async function discoverDatasets(projectRoot) {
+  const datasetsDir = join(projectRoot, "datasets");
+  const modulePaths = await listModuleFiles(datasetsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "dataset"
+  });
+  const datasets = [];
+  for (const candidate of exportedCandidates) {
+    if (isDatasetDefinition(candidate)) {
+      datasets.push(candidate);
+    }
+  }
+  return datasets;
+}
+async function discoverSyncs(projectRoot) {
+  const syncsDir = join(projectRoot, "syncs");
+  const modulePaths = await listModuleFiles(syncsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "sync"
+  });
+  const syncs = [];
+  for (const candidate of exportedCandidates) {
+    if (isSyncDefinition(candidate)) {
+      syncs.push(candidate);
+    }
+  }
+  return syncs;
+}
+async function discoverProjections(projectRoot) {
+  const projectionsDir = join(projectRoot, "projections");
+  const modulePaths = await listModuleFiles(projectionsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "projection"
+  });
+  const projections = [];
+  for (const candidate of exportedCandidates) {
+    if (isProjectionDefinition(candidate)) {
+      projections.push(candidate);
+    }
+  }
+  return projections;
+}
+async function discoverConnectors(projectRoot) {
+  const connectorsDir = join(projectRoot, "connectors");
+  const modulePaths = await listModuleFiles(connectorsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "connector"
+  });
+  const connectors = [];
+  for (const candidate of exportedCandidates) {
+    if (isConnectorDefinition(candidate)) {
+      connectors.push(candidate);
+    }
+  }
+  return connectors;
+}
+async function discoverSchedules(projectRoot) {
+  const schedulesDir = join(projectRoot, "schedules");
+  const modulePaths = await listModuleFiles(schedulesDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "schedule"
+  });
+  const schedules = [];
+  for (const candidate of exportedCandidates) {
+    if (isScheduleDefinition(candidate)) {
+      schedules.push(candidate);
+    }
+  }
+  return schedules;
+}
+async function discoverPipelines(projectRoot) {
+  const pipelinesDir = join(projectRoot, "pipelines");
+  const modulePaths = await listModuleFiles(pipelinesDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "pipeline"
+  });
+  const pipelines = [];
+  for (const candidate of exportedCandidates) {
+    if (isPipelineDefinition(candidate)) {
+      pipelines.push(candidate);
+    }
+  }
+  return pipelines;
+}
+async function discoverRules(projectRoot) {
+  const rulesDir = join(projectRoot, "rules");
+  const modulePaths = await listModuleFiles(rulesDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "rule"
+  });
+  const rules = [];
+  for (const candidate of exportedCandidates) {
+    if (isRuleDefinition(candidate)) {
+      rules.push(candidate);
+    }
+  }
+  return rules;
+}
+async function discoverGroups(projectRoot) {
+  const groupsDir = join(projectRoot, "security", "groups");
+  const modulePaths = await listModuleFiles(groupsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "group"
+  });
+  const groups = [];
+  for (const candidate of exportedCandidates) {
+    if (isGroupDefinition(candidate)) {
+      groups.push(candidate);
+    }
+  }
+  return groups;
+}
+async function discoverRoles(projectRoot) {
+  const rolesDir = join(projectRoot, "security", "roles");
+  const modulePaths = await listModuleFiles(rolesDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "role"
+  });
+  const roles = [];
+  for (const candidate of exportedCandidates) {
+    if (isRoleDefinition(candidate)) {
+      roles.push(candidate);
+    }
+  }
+  return roles;
+}
+async function discoverMembershipPolicies(projectRoot) {
+  const policiesDir = join(projectRoot, "security", "policies");
+  const modulePaths = await listModuleFiles(policiesDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "membershipPolicy"
+  });
+  const membershipPolicies = [];
+  for (const candidate of exportedCandidates) {
+    if (isMembershipPolicyDefinition(candidate)) {
+      membershipPolicies.push(candidate);
+    }
+  }
+  return membershipPolicies;
+}
+async function discoverWorkflows(projectRoot) {
+  const workflowsDir = join(projectRoot, "workflows");
+  const modulePaths = await listModuleFiles(workflowsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "workflow"
+  });
+  const workflows = [];
+  for (const candidate of exportedCandidates) {
+    if (isWorkflowDefinition(candidate)) {
+      workflows.push(candidate);
+    }
+  }
+  return workflows;
+}
+async function discoverAgents(projectRoot) {
+  const agentsDir = join(projectRoot, "agents");
+  const modulePaths = await listModuleFiles(agentsDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "agent"
+  });
+  const agents = [];
+  for (const candidate of exportedCandidates) {
+    if (isAgentDefinition(candidate)) {
+      agents.push(candidate);
+    }
+  }
+  return agents;
+}
+async function loadModuleExports(options) {
+  const exportedCandidates = [];
+  const seen = new Set;
+  for (const modulePath of options.modulePaths) {
+    let moduleNamespace;
+    try {
+      moduleNamespace = await import(pathToFileURL(modulePath).href);
+    } catch (error) {
+      const relPath = relative(options.projectRoot, modulePath);
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new RuntimeError(`Failed to load ${options.kind} module '${relPath}': ${reason}`);
+    }
+    for (const exportedValue of Object.values(moduleNamespace)) {
+      collectExportedCandidates(exportedValue, exportedCandidates, seen);
+    }
+  }
+  return exportedCandidates;
+}
+function collectExportedCandidates(value, target, seen) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectExportedCandidates(item, target, seen);
+    }
+    return;
+  }
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value === "object" && value !== null || typeof value === "function") {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+  }
+  target.push(value);
+}
+async function listModuleFiles(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const files = [];
+  const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sortedEntries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listModuleFiles(fullPath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!hasSupportedModuleExtension(entry.name)) {
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files;
+}
+function isNotFoundError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function hasSupportedModuleExtension(fileName) {
+  const normalized = fileName.toLowerCase();
+  for (const extension of moduleExtensions) {
+    if (normalized.endsWith(extension)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOntologyDocumentInput(value) {
+  if (!isRecord5(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.version === "string" && Array.isArray(value.objectTypes);
+}
+function isObjectTypeWithPropertyTokens(value) {
+  if (!isRecord5(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && Array.isArray(value.properties) && Array.isArray(value.links) && isRecord5(value.p);
+}
+function isValueType(value) {
+  if (!isRecord5(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.name === "string" && "schema" in value && !Array.isArray(value.properties) && !Array.isArray(value.objectTypes);
+}
+// src/bootstrap/ontology-type-manifest.ts
+import { mkdir, readdir as readdir2, readFile, writeFile } from "fs/promises";
+import { dirname, extname, join as join2, relative as relative2, resolve, sep } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var moduleExtensions2 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+async function discoverOntologyTypeManifest(projectRoot) {
+  const resolvedProjectRoot = resolve(projectRoot);
+  const ontologyDir = join2(resolvedProjectRoot, "ontology");
+  const modulePaths = await listModuleFiles2(ontologyDir);
+  const entries = new Map;
+  const seenObjectTypes = new Set;
+  for (const modulePath of modulePaths) {
+    const moduleSpecifier = toGeneratedModuleSpecifier({
+      fromDir: join2(resolvedProjectRoot, ".sixb", "types"),
+      modulePath
+    });
+    const moduleNamespace = await loadOntologyModule({
+      modulePath,
+      projectRoot: resolvedProjectRoot
+    });
+    for (const [exportName, exportedValue] of Object.entries(moduleNamespace)) {
+      collectManifestEntries({
+        exportedValue,
+        exportName,
+        modulePath,
+        moduleSpecifier,
+        entries,
+        seenObjectTypes
+      });
+    }
+  }
+  return {
+    entries: [...entries.values()].sort((a, b) => a.objectTypeId.localeCompare(b.objectTypeId)),
+    moduleCount: modulePaths.length
+  };
+}
+async function generateOntologyTypeManifest(options) {
+  const projectRoot = resolve(options.projectRoot);
+  const outFile = resolve(projectRoot, options.outFile ?? join2(".sixb", "types", "ontology.d.ts"));
+  const discovery = await discoverOntologyTypeManifest(projectRoot);
+  if (discovery.moduleCount === 0) {
+    return {
+      ...discovery,
+      path: outFile,
+      written: false,
+      skipped: true
+    };
+  }
+  const content = renderOntologyTypeManifest(discovery.entries);
+  await mkdir(dirname(outFile), { recursive: true });
+  const written = await writeFileIfChanged(outFile, content);
+  return {
+    ...discovery,
+    path: outFile,
+    written,
+    skipped: false
+  };
+}
+function collectManifestEntries(input) {
+  if (isObjectTypeWithPropertyTokens2(input.exportedValue)) {
+    addManifestEntry({
+      objectType: input.exportedValue,
+      modulePath: input.modulePath,
+      exportName: input.exportName,
+      typeExpression: `typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}]`,
+      entries: input.entries,
+      seenObjectTypes: input.seenObjectTypes
+    });
+    return;
+  }
+  if (isOntologyDocumentInput2(input.exportedValue)) {
+    for (const objectType of input.exportedValue.objectTypes) {
+      addManifestEntry({
+        objectType,
+        modulePath: input.modulePath,
+        exportName: input.exportName,
+        typeExpression: `Extract<(typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}])["objectTypes"][number], { id: ${JSON.stringify(objectType.id)} }>`,
+        entries: input.entries,
+        seenObjectTypes: input.seenObjectTypes
+      });
+    }
+    return;
+  }
+  if (Array.isArray(input.exportedValue)) {
+    for (const item of input.exportedValue) {
+      if (!isObjectTypeWithPropertyTokens2(item))
+        continue;
+      addManifestEntry({
+        objectType: item,
+        modulePath: input.modulePath,
+        exportName: input.exportName,
+        typeExpression: `Extract<(typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}])[number], { id: ${JSON.stringify(item.id)} }>`,
+        entries: input.entries,
+        seenObjectTypes: input.seenObjectTypes
+      });
+    }
+  }
+}
+function addManifestEntry(input) {
+  if (input.seenObjectTypes.has(input.objectType)) {
+    return;
+  }
+  input.seenObjectTypes.add(input.objectType);
+  const existing = input.entries.get(input.objectType.id);
+  const entry = {
+    objectTypeId: input.objectType.id,
+    modulePath: input.modulePath,
+    exportName: input.exportName,
+    typeExpression: input.typeExpression
+  };
+  if (!existing) {
+    input.entries.set(input.objectType.id, entry);
+    return;
+  }
+  throw new RuntimeError(`[Sixb] Duplicate ontology object type id "${input.objectType.id}" while generating `.concat(`the type manifest: ${relative2(process.cwd(), existing.modulePath)} and `, `${relative2(process.cwd(), input.modulePath)}.`));
+}
+function renderOntologyTypeManifest(entries) {
+  const lines = [
+    "// This file is auto-generated by Sixb.",
+    "// Do not edit this file directly.",
+    "",
+    'declare module "@sixb/core/ontology" {',
+    "  interface SixbObjectTypeMap {"
+  ];
+  for (const entry of entries) {
+    lines.push(`    ${JSON.stringify(entry.objectTypeId)}: ${entry.typeExpression}`);
+  }
+  lines.push("  }", "}", "", "export {}", "");
+  return lines.join(`
+`);
+}
+async function writeFileIfChanged(path, content) {
+  try {
+    const existing = await readFile(path, "utf-8");
+    if (existing === content)
+      return false;
+  } catch (error) {
+    if (!isNotFoundError2(error))
+      throw error;
+  }
+  await writeFile(path, content, "utf-8");
+  return true;
+}
+async function loadOntologyModule(input) {
+  try {
+    return await import(pathToFileURL2(input.modulePath).href);
+  } catch (error) {
+    const relPath = relative2(input.projectRoot, input.modulePath);
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new RuntimeError(`Failed to load ontology module '${relPath}': ${reason}`);
+  }
+}
+async function listModuleFiles2(dir) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const files = [];
+  const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sortedEntries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listModuleFiles2(fullPath));
+      continue;
+    }
+    if (!entry.isFile() || !hasSupportedModuleExtension2(entry.name)) {
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files;
+}
+function toGeneratedModuleSpecifier(input) {
+  const withoutExtension = stripSupportedModuleExtension(input.modulePath);
+  const relativePath = relative2(input.fromDir, withoutExtension).split(sep).join("/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function stripSupportedModuleExtension(path) {
+  const extension = extname(path);
+  return moduleExtensions2.has(extension) ? path.slice(0, -extension.length) : path;
+}
+function hasSupportedModuleExtension2(fileName) {
+  return moduleExtensions2.has(extname(fileName).toLowerCase());
+}
+function isNotFoundError2(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isObjectTypeWithPropertyTokens2(value) {
+  if (!isRecord6(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && Array.isArray(value.properties) && Array.isArray(value.links) && isRecord6(value.p);
+}
+function isOntologyDocumentInput2(value) {
+  if (!isRecord6(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.version === "string" && Array.isArray(value.objectTypes);
+}
+export { ConnectorError, ConnectorNotFoundError, defineConnector, col, defineDataset, PipelineError, definePipelineStep, definePipeline, requestPipelineRun, isPipelineDefinition, isPipelineStepDefinition, RuleValidationError, isRuleDefinition, validateRulesAtStartup, defineRule, SyncValidationError, defineSync, requestSyncRun, discoverOntologySources, discoverActions, discoverDatasets, discoverSyncs, discoverProjections, discoverConnectors, discoverSchedules, discoverPipelines, discoverRules, discoverGroups, discoverRoles, discoverMembershipPolicies, discoverWorkflows, discoverAgents, discoverOntologyTypeManifest, generateOntologyTypeManifest };
+
+//# debugId=9E9FDA3EA37DC23D64756E2164756E21