@sixb/core 0.1.0 → 0.1.2

package/dist/chunk-pv1yad91.js

@@ -1,1165 +0,0 @@
-// @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