@a-company/paradigm 3.12.0 → 3.13.0

package/dist/dist-KY5HGDDL.js

@@ -0,0 +1,1304 @@
+#!/usr/bin/env node
+
+// ../premise/core/dist/index.js
+import * as fs3 from "fs";
+import * as yaml3 from "js-yaml";
+import { z as z2 } from "zod";
+import * as path3 from "path";
+
+// ../purpose/core/dist/index.js
+import * as fs from "fs";
+import * as yaml from "js-yaml";
+import { z } from "zod";
+import * as path from "path";
+import { glob } from "glob";
+var PurposeItemSchema = z.object({
+  description: z.string(),
+  endpoints: z.array(z.string()).optional(),
+  tests: z.array(z.string()).optional(),
+  rules: z.record(z.unknown()).optional(),
+  aspects: z.array(z.string()).optional(),
+  // Symbol reference arrays
+  flows: z.array(z.string()).optional(),
+  gates: z.array(z.string()).optional(),
+  signals: z.array(z.string()).optional(),
+  states: z.array(z.string()).optional(),
+  components: z.array(z.string()).optional(),
+  // Extra fields preserved
+  tags: z.array(z.string()).optional(),
+  location: z.string().optional(),
+  locations: z.array(z.string()).optional(),
+  uses: z.array(z.string()).optional(),
+  "used-by": z.array(z.string()).optional(),
+  "used-for": z.array(z.string()).optional(),
+  exports: z.array(z.string()).optional(),
+  status: z.string().optional(),
+  properties: z.record(z.unknown()).optional(),
+  handles: z.array(z.string()).optional()
+}).passthrough();
+var PurposeItemArraySchema = PurposeItemSchema.extend({
+  id: z.string()
+});
+var SignalDefinitionObjectSchema = z.object({
+  description: z.string().optional(),
+  category: z.string().optional(),
+  severity: z.enum(["info", "warn", "error"]).optional(),
+  emitters: z.array(z.string()).optional(),
+  related: z.array(z.string()).optional(),
+  data: z.record(z.unknown()).optional()
+});
+var SignalDefinitionSchema = z.union([
+  SignalDefinitionObjectSchema,
+  z.string().transform((desc) => ({ description: desc }))
+]);
+var RelationshipObjectSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  type: z.string(),
+  description: z.string().optional()
+});
+var RelationshipSchema = z.union([RelationshipObjectSchema, z.string()]);
+var FlowStepObjectSchema = z.object({
+  component: z.string(),
+  action: z.string(),
+  description: z.string().optional()
+});
+var FlowStepSchema = z.union([FlowStepObjectSchema, z.string()]);
+var FlowWithStepsSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  steps: z.array(FlowStepSchema)
+});
+var FlowDefinitionSchema = z.object({
+  description: z.string().optional(),
+  gates: z.array(z.string()).optional(),
+  signals: z.array(z.string()).optional(),
+  components: z.array(z.string()).optional(),
+  steps: z.array(FlowStepSchema).optional()
+});
+var GateDefinitionSchema = z.object({
+  description: z.string().optional(),
+  requires: z.array(z.string()).optional(),
+  keys: z.array(z.string()).optional(),
+  signals: z.array(z.string()).optional()
+});
+var StateDefinitionSchema = z.object({
+  description: z.string().optional(),
+  default: z.unknown().optional(),
+  type: z.string().optional()
+});
+var AspectDefinitionSchema = z.object({
+  description: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  anchors: z.array(z.string()).optional(),
+  "applies-to": z.array(z.string()).optional(),
+  enforcement: z.string().optional()
+});
+var ReferenceSchema = z.object({
+  target: z.string(),
+  type: z.string(),
+  path: z.string()
+});
+var PurposeFileSchema = z.object({
+  version: z.string().optional(),
+  description: z.string().optional(),
+  apiSpec: z.string().optional(),
+  context: z.array(z.string()).optional(),
+  rules: z.record(z.unknown()).optional(),
+  // Support both array format [{ id, description }] and record format { id: { description } }
+  features: z.union([
+    z.array(PurposeItemArraySchema),
+    z.record(PurposeItemSchema)
+  ]).optional(),
+  components: z.union([
+    z.array(PurposeItemArraySchema),
+    z.record(PurposeItemSchema)
+  ]).optional(),
+  gates: z.record(GateDefinitionSchema).optional(),
+  states: z.record(StateDefinitionSchema).optional(),
+  signals: z.record(SignalDefinitionSchema).optional(),
+  aspects: z.record(AspectDefinitionSchema).optional(),
+  relationships: z.array(RelationshipSchema).optional(),
+  // Support both array format and record format for flows
+  flows: z.union([
+    z.array(FlowWithStepsSchema),
+    z.record(FlowDefinitionSchema)
+  ]).optional(),
+  references: z.array(ReferenceSchema).optional()
+});
+function parsePurposeFile(filePath) {
+  const result = parsePurposeFileDetailed(filePath);
+  return { data: result.data, errors: result.errors };
+}
+function parsePurposeFileDetailed(filePath) {
+  const errors = [];
+  const detailedErrors = [];
+  let rawContent;
+  try {
+    rawContent = fs.readFileSync(filePath, "utf8");
+  } catch (e) {
+    const error = `Cannot read file: ${e.message}`;
+    errors.push(error);
+    detailedErrors.push({ message: error, type: "file" });
+    return { data: null, errors, detailedErrors, rawContent: void 0, isYamlValid: false };
+  }
+  const processedContent = rawContent.replace(/^([#~!$^][\w-]+):/gm, '"$1":').replace(/^(\s*-\s+)([!#][\w-]+)$/gm, '$1"$2"');
+  let data = null;
+  try {
+    data = yaml.load(processedContent);
+  } catch (e) {
+    const yamlError = e;
+    const line = yamlError.mark?.line ? yamlError.mark.line + 1 : void 0;
+    const message = `YAML syntax error: ${yamlError.reason || e.message}`;
+    errors.push(`${message}${line ? ` (line ${line})` : ""}`);
+    detailedErrors.push({
+      message,
+      line,
+      type: "yaml"
+    });
+    return { data: null, errors, detailedErrors, rawContent, isYamlValid: false };
+  }
+  if (data === null || data === void 0) {
+    return {
+      data: {},
+      errors: [],
+      detailedErrors: [],
+      rawContent,
+      isYamlValid: true
+    };
+  }
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    const prefixMap = {
+      "#": "components",
+      "$": "flows",
+      "^": "gates",
+      "!": "signals",
+      "~": "aspects"
+    };
+    for (const key of Object.keys(obj)) {
+      const prefix = key[0];
+      const target = prefixMap[prefix];
+      if (!target || key.length < 2) continue;
+      const id = key.slice(1);
+      const value = obj[key];
+      if (typeof value !== "object" || value === null) continue;
+      const dict = obj[target] || {};
+      if (!(target in obj)) obj[target] = dict;
+      if (!(id in dict)) dict[id] = value;
+      delete obj[key];
+    }
+  }
+  const parseResult = PurposeFileSchema.safeParse(data);
+  if (!parseResult.success) {
+    for (const issue of parseResult.error.issues) {
+      const path22 = issue.path.join(".");
+      const message = issue.message;
+      errors.push(`Schema error at ${path22 || "/"}: ${message}`);
+      detailedErrors.push({
+        message,
+        path: path22 || "/",
+        type: "schema"
+      });
+    }
+    return { data, errors, detailedErrors, rawContent, isYamlValid: true };
+  }
+  return { data: parseResult.data, errors: [], detailedErrors: [], rawContent, isYamlValid: true };
+}
+function normalizeItemsToEntries(items) {
+  if (!items) return [];
+  if (Array.isArray(items)) {
+    return items.map((item) => [item.id, item]);
+  } else {
+    return Object.entries(items);
+  }
+}
+async function findPurposeFiles(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  const files = await glob("**/.purpose", {
+    cwd: absoluteRoot,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  return files.sort((a, b) => {
+    const depthA = a.split(path.sep).length;
+    const depthB = b.split(path.sep).length;
+    return depthA - depthB;
+  });
+}
+async function getAllPurposeFiles(rootDir) {
+  const files = await findPurposeFiles(rootDir);
+  const parsed = [];
+  for (const filePath of files) {
+    const { data, errors } = parsePurposeFile(filePath);
+    if (data) {
+      parsed.push({ filePath, data });
+      if (errors.length > 0) {
+        console.warn(`Warnings parsing ${filePath}:`, errors);
+      }
+    }
+  }
+  return parsed;
+}
+function extractFeatures(parsedFiles) {
+  const features = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    const entries = normalizeItemsToEntries(data.features);
+    for (const [id, item] of entries) {
+      features.set(id, { item, filePath });
+    }
+  }
+  return features;
+}
+function extractComponents(parsedFiles) {
+  const components = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    const entries = normalizeItemsToEntries(data.components);
+    for (const [id, item] of entries) {
+      components.set(id, { item, filePath });
+    }
+  }
+  return components;
+}
+function extractGates(parsedFiles) {
+  const gates = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.gates) {
+      for (const [id, item] of Object.entries(data.gates)) {
+        gates.set(id, { item, filePath });
+      }
+    }
+  }
+  return gates;
+}
+function extractStates(parsedFiles) {
+  const states = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.states) {
+      for (const [id, item] of Object.entries(data.states)) {
+        states.set(id, { item, filePath });
+      }
+    }
+  }
+  return states;
+}
+function extractFlows(parsedFiles) {
+  const flows = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.flows) {
+      if (Array.isArray(data.flows)) {
+        for (const flow of data.flows) {
+          flows.set(flow.name, {
+            item: {
+              id: flow.name,
+              description: flow.description,
+              steps: flow.steps
+            },
+            filePath
+          });
+        }
+      } else {
+        for (const [id, flowDef] of Object.entries(data.flows)) {
+          flows.set(id, {
+            item: {
+              id,
+              description: flowDef.description,
+              gates: flowDef.gates,
+              signals: flowDef.signals,
+              components: flowDef.components,
+              steps: flowDef.steps
+            },
+            filePath
+          });
+        }
+      }
+    }
+  }
+  return flows;
+}
+function extractSignals(parsedFiles) {
+  const signals = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.signals) {
+      for (const [id, item] of Object.entries(data.signals)) {
+        signals.set(id, { item, filePath });
+      }
+    }
+  }
+  return signals;
+}
+function extractAspects(parsedFiles) {
+  const aspects = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.aspects) {
+      for (const [id, item] of Object.entries(data.aspects)) {
+        aspects.set(id, { item, filePath });
+      }
+    }
+  }
+  return aspects;
+}
+function extractSymbolReferences(parsedFiles) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { filePath, data } of parsedFiles) {
+    const featureEntries = normalizeItemsToEntries(data.features);
+    for (const [id, item] of featureEntries) {
+      extractRefsFromItem(`#${id}`, item, filePath, refs, seen);
+    }
+    const componentEntries = normalizeItemsToEntries(data.components);
+    for (const [id, item] of componentEntries) {
+      extractRefsFromItem(`#${id}`, item, filePath, refs, seen);
+    }
+  }
+  return refs;
+}
+function extractRefsFromItem(sourceSymbol, item, filePath, refs, seen) {
+  if (item.flows) {
+    for (const flow of item.flows) {
+      const symbol = flow.startsWith("$") ? flow : `$${flow}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "flow", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.gates) {
+    for (const gate of item.gates) {
+      const symbol = gate.startsWith("^") ? gate : `^${gate}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "gate", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.signals) {
+    for (const signal of item.signals) {
+      const symbol = signal.startsWith("!") ? signal : `!${signal}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "signal", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.states) {
+    for (const state of item.states) {
+      const symbol = state.startsWith("#") ? state : state.startsWith("%") ? `#${state.slice(1)}` : `#${state}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "component", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.components) {
+    for (const comp of item.components) {
+      const symbol = comp.startsWith("#") ? comp : `#${comp}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "component", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.aspects) {
+    for (const aspect of item.aspects) {
+      const symbol = aspect.startsWith("~") ? aspect : `~${aspect}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "aspect", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.description) {
+    const descRefs = extractSymbolsFromText(item.description);
+    for (const { symbol, type } of descRefs) {
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type, sourceSymbol, filePath });
+      }
+    }
+  }
+}
+var SYMBOL_BLOCKLIST = /* @__PURE__ */ new Set([
+  "$lib",
+  "$env",
+  "$app",
+  "$service-worker",
+  "$virtual",
+  "$schema",
+  "$ref",
+  "$id",
+  "$type"
+]);
+function extractSymbolsFromText(text) {
+  const results = [];
+  const pattern = /([$^!#~%])([a-zA-Z][a-zA-Z0-9._-]*)/g;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    const prefix = match[1];
+    const id = match[2];
+    let symbol;
+    let type;
+    switch (prefix) {
+      case "#":
+        type = "component";
+        symbol = `#${id}`;
+        break;
+      case "$":
+        type = "flow";
+        symbol = `$${id}`;
+        break;
+      case "^":
+        type = "gate";
+        symbol = `^${id}`;
+        break;
+      case "!":
+        type = "signal";
+        symbol = `!${id}`;
+        break;
+      case "~":
+        type = "aspect";
+        symbol = `~${id}`;
+        break;
+      // Legacy: %state → #component
+      case "%":
+        type = "component";
+        symbol = `#${id}`;
+        break;
+      default:
+        continue;
+    }
+    if (SYMBOL_BLOCKLIST.has(symbol)) continue;
+    results.push({ symbol, type });
+  }
+  return results;
+}
+
+// ../portal/core/dist/index.js
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as yaml2 from "js-yaml";
+import { glob as glob2 } from "glob";
+var DEFAULT_DEV_SETTINGS = {
+  visualizerPort: 42195,
+  // Marathon: 42.195km
+  watcherPort: 42196,
+  // Marathon + 1
+  autoConnect: true
+};
+async function parseGateConfig(configPath) {
+  const absolutePath = path2.resolve(configPath);
+  const rootDir = path2.dirname(absolutePath);
+  if (!fs2.existsSync(absolutePath)) {
+    throw new Error(`Gate config not found: ${absolutePath}`);
+  }
+  const content = fs2.readFileSync(absolutePath, "utf8");
+  const config = yaml2.load(content);
+  if (!config.version) {
+    throw new Error('Gate config missing required "version" field');
+  }
+  const gates = [];
+  const configAny = config;
+  const gatesSource = config.gates || configAny.portals;
+  if (gatesSource) {
+    for (const [id, gateDef] of Object.entries(gatesSource)) {
+      gates.push(normalizeGate(id, gateDef));
+    }
+  }
+  if (config.include) {
+    for (const pattern of config.include) {
+      const fullPattern = path2.join(rootDir, pattern);
+      const files = await glob2(fullPattern.replace(/\\/g, "/"));
+      for (const file of files) {
+        const additionalGates = await parseGateFile(file);
+        gates.push(...additionalGates);
+      }
+    }
+  }
+  const flows = [];
+  if (config.flows) {
+    for (const [id, flowDef] of Object.entries(config.flows)) {
+      flows.push(normalizeFlow(id, flowDef));
+    }
+  }
+  return {
+    version: config.version,
+    gates,
+    flows,
+    settings: {
+      dev: {
+        ...DEFAULT_DEV_SETTINGS,
+        ...config.settings?.dev
+      }
+    }
+  };
+}
+async function parseGateFile(filePath) {
+  const content = fs2.readFileSync(filePath, "utf8");
+  const data = yaml2.load(content);
+  if (data.id) {
+    return [normalizeGate(data.id, data)];
+  }
+  if (data.gates) {
+    const gates = [];
+    for (const [id, gateDef] of Object.entries(data.gates)) {
+      gates.push(normalizeGate(id, gateDef));
+    }
+    return gates;
+  }
+  return [];
+}
+function normalizeGate(id, def) {
+  const locks = [];
+  if (def.locks) {
+    for (const lockDef of def.locks) {
+      locks.push(normalizeLock(lockDef));
+    }
+  }
+  const prizes = [];
+  if (def.prizes) {
+    for (const prizeDef of def.prizes) {
+      prizes.push(normalizePrize(prizeDef));
+    }
+  }
+  return {
+    id,
+    description: def.description,
+    locks,
+    prizes,
+    position: def.position
+  };
+}
+function normalizeLock(def) {
+  const lockDef = def;
+  const keys = [];
+  if (lockDef.keys) {
+    for (const keyDef of lockDef.keys) {
+      if (typeof keyDef === "string") {
+        keys.push({ expression: keyDef });
+      } else if (keyDef.expression) {
+        const k = keyDef;
+        keys.push({
+          expression: k.expression,
+          description: k.description
+        });
+      }
+    }
+  }
+  return {
+    id: lockDef.id,
+    description: lockDef.description,
+    keys,
+    mode: lockDef.mode || "all"
+  };
+}
+function normalizePrize(def) {
+  const prizeDef = def;
+  return {
+    id: prizeDef.id,
+    oneTime: prizeDef.oneTime ?? false,
+    metadata: prizeDef.metadata
+  };
+}
+function normalizeFlow(id, def) {
+  return {
+    id,
+    description: def.description,
+    gates: def.gates || [],
+    forkable: def.forkable
+  };
+}
+async function findGateFiles(rootDir) {
+  const absoluteRoot = path2.resolve(rootDir);
+  const files = await glob2("**/portal.yaml", {
+    cwd: absoluteRoot,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  return files;
+}
+
+// ../premise/core/dist/index.js
+var SYMBOL_PREFIXES = {
+  component: "#",
+  flow: "$",
+  gate: "^",
+  signal: "!",
+  aspect: "~"
+};
+var PREFIX_TO_TYPE = {
+  "#": "component",
+  "$": "flow",
+  "^": "gate",
+  "!": "signal",
+  "~": "aspect"
+};
+var VALID_PREFIXES = ["#", "$", "^", "!", "~"];
+function isValidPrefix(prefix) {
+  return VALID_PREFIXES.includes(prefix);
+}
+var PositionSchema = z2.object({
+  x: z2.number(),
+  y: z2.number()
+});
+var ViewportSchema = z2.object({
+  x: z2.number(),
+  y: z2.number(),
+  zoom: z2.number()
+});
+var PremiseSourceConfigSchema = z2.object({
+  path: z2.string(),
+  include: z2.array(z2.string()).optional(),
+  exclude: z2.array(z2.string()).optional()
+});
+var PremiseNodeSchema = z2.object({
+  id: z2.string(),
+  symbol: z2.string(),
+  type: z2.enum(["feature", "component", "flow", "state", "aspect", "gate", "signal", "idea"]),
+  content: z2.string().optional(),
+  position: PositionSchema,
+  tags: z2.array(z2.string()).optional(),
+  created: z2.string(),
+  modified: z2.string().optional()
+});
+var PremiseConnectionSchema = z2.object({
+  from: z2.string(),
+  to: z2.string(),
+  label: z2.string().optional(),
+  type: z2.string().optional()
+});
+var PremiseGroupSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  nodes: z2.array(z2.string()),
+  color: z2.string().optional()
+});
+var PremiseLayoutSchema = z2.object({
+  viewport: ViewportSchema,
+  groups: z2.array(PremiseGroupSchema).optional()
+});
+var PremiseSnapshotStateSchema = z2.object({
+  nodes: z2.array(PremiseNodeSchema),
+  connections: z2.array(PremiseConnectionSchema),
+  layout: PremiseLayoutSchema
+});
+var PremiseSnapshotSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  timestamp: z2.string(),
+  description: z2.string().optional(),
+  state: PremiseSnapshotStateSchema
+});
+var PremiseFileSchema = z2.object({
+  version: z2.string(),
+  metadata: z2.object({
+    name: z2.string(),
+    created: z2.string(),
+    modified: z2.string()
+  }),
+  sources: z2.object({
+    purpose: z2.array(PremiseSourceConfigSchema).optional(),
+    portal: z2.array(PremiseSourceConfigSchema).optional()
+  }),
+  nodes: z2.array(PremiseNodeSchema),
+  connections: z2.array(PremiseConnectionSchema),
+  layout: PremiseLayoutSchema,
+  snapshots: z2.array(PremiseSnapshotSchema).optional()
+});
+function parsePremiseFile(filePath) {
+  const errors = [];
+  let rawContent;
+  try {
+    rawContent = fs3.readFileSync(filePath, "utf8");
+  } catch (e) {
+    errors.push(`Cannot read file: ${e.message}`);
+    return { data: null, errors, rawContent: void 0 };
+  }
+  return parsePremiseContent(rawContent);
+}
+function parsePremiseContent(content) {
+  const errors = [];
+  let data = null;
+  try {
+    data = yaml3.load(content);
+  } catch (e) {
+    const yamlError = e;
+    const line = yamlError.mark?.line ? yamlError.mark.line + 1 : void 0;
+    errors.push(`YAML syntax error: ${yamlError.reason || e.message}${line ? ` (line ${line})` : ""}`);
+    return { data: null, errors, rawContent: content };
+  }
+  if (data === null || data === void 0) {
+    return {
+      data: createEmptyPremiseFile(),
+      errors: [],
+      rawContent: content
+    };
+  }
+  const parseResult = PremiseFileSchema.safeParse(data);
+  if (!parseResult.success) {
+    for (const issue of parseResult.error.issues) {
+      const path22 = issue.path.join(".");
+      errors.push(`Schema error at ${path22 || "/"}: ${issue.message}`);
+    }
+    return { data, errors, rawContent: content };
+  }
+  return { data: parseResult.data, errors: [], rawContent: content };
+}
+function createEmptyPremiseFile(name = "Untitled") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.0.0",
+    metadata: {
+      name,
+      created: now,
+      modified: now
+    },
+    sources: {
+      purpose: [{ path: "./" }],
+      portal: [{ path: "./portal.yaml" }]
+    },
+    nodes: [],
+    connections: [],
+    layout: {
+      viewport: { x: 0, y: 0, zoom: 1 }
+    }
+  };
+}
+function serializePremiseFile(data) {
+  data.metadata.modified = (/* @__PURE__ */ new Date()).toISOString();
+  return yaml3.dump(data, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false
+  });
+}
+function getDefaultPremiseContent(projectName = "My Project") {
+  return serializePremiseFile(createEmptyPremiseFile(projectName));
+}
+function addPremiseNode(premiseFile, node) {
+  return {
+    ...premiseFile,
+    nodes: [...premiseFile.nodes, node],
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function updateNodePosition(premiseFile, nodeId, position) {
+  return {
+    ...premiseFile,
+    nodes: premiseFile.nodes.map(
+      (n) => n.id === nodeId ? { ...n, position, modified: (/* @__PURE__ */ new Date()).toISOString() } : n
+    ),
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function addConnection(premiseFile, connection) {
+  const exists = premiseFile.connections.some(
+    (c) => c.from === connection.from && c.to === connection.to
+  );
+  if (exists) return premiseFile;
+  return {
+    ...premiseFile,
+    connections: [...premiseFile.connections, connection],
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createSnapshot(premiseFile, name, description) {
+  const snapshot = {
+    id: `snap-${Date.now()}`,
+    name,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    description,
+    state: {
+      nodes: [...premiseFile.nodes],
+      connections: [...premiseFile.connections],
+      layout: { ...premiseFile.layout }
+    }
+  };
+  return {
+    ...premiseFile,
+    snapshots: [...premiseFile.snapshots || [], snapshot],
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function aggregateFromPremise(premiseFile, rootDir) {
+  const symbols = [];
+  const errors = [];
+  const purposeFiles = [];
+  const portalFiles = [];
+  if (premiseFile.sources.purpose) {
+    for (const source of premiseFile.sources.purpose) {
+      const sourcePath = path3.resolve(rootDir, source.path);
+      try {
+        const parsed = await getAllPurposeFiles(sourcePath);
+        purposeFiles.push(...parsed.map((p) => p.filePath));
+        const features = extractFeatures(parsed);
+        for (const [id, { item, filePath }] of features) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-feature-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            tags: ["feature"]
+          }));
+        }
+        const components = extractComponents(parsed);
+        for (const [id, { item, filePath }] of components) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-component-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const gates = extractGates(parsed);
+        for (const [id, { item, filePath }] of gates) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-gate-${id}`,
+            symbol: `^${id}`,
+            type: "gate",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const states = extractStates(parsed);
+        for (const [id, { item, filePath }] of states) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-state-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            tags: ["state"]
+          }));
+        }
+        const flows = extractFlows(parsed);
+        for (const [id, { item, filePath }] of flows) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-flow-${id}`,
+            symbol: `$${id}`,
+            type: "flow",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const signals = extractSignals(parsed);
+        for (const [id, { item, filePath }] of signals) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-signal-${id}`,
+            symbol: `!${id}`,
+            type: "signal",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const aspects = extractAspects(parsed);
+        for (const [id, { item, filePath }] of aspects) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-aspect-${id}`,
+            symbol: `~${id}`,
+            type: "aspect",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            anchors: item.anchors?.map((a) => parseAnchorString(a)),
+            appliesTo: item["applies-to"],
+            tags: item.tags,
+            enforcement: item.enforcement
+          }));
+        }
+        const symbolRefs = extractSymbolReferences(parsed);
+        const existingSymbols = new Set(symbols.map((s) => s.symbol));
+        for (const ref of symbolRefs) {
+          if (!existingSymbols.has(ref.symbol)) {
+            existingSymbols.add(ref.symbol);
+            symbols.push(createSymbolEntry({
+              id: `purpose-ref-${ref.type}-${ref.symbol.slice(1)}`,
+              symbol: ref.symbol,
+              type: ref.type,
+              source: "purpose",
+              filePath: ref.filePath,
+              data: { referencedFrom: ref.sourceSymbol },
+              description: `Referenced from ${ref.sourceSymbol}`
+            }));
+          }
+        }
+      } catch (e) {
+        errors.push({
+          source: "purpose",
+          filePath: sourcePath,
+          message: e.message
+        });
+      }
+    }
+  }
+  if (premiseFile.sources.portal) {
+    for (const source of premiseFile.sources.portal) {
+      const sourcePath = path3.resolve(rootDir, source.path);
+      try {
+        let gateConfig;
+        if (sourcePath.endsWith(".yaml") || sourcePath.endsWith(".yml")) {
+          gateConfig = await parseGateConfig(sourcePath);
+          portalFiles.push(sourcePath);
+        } else {
+          const files = await findGateFiles(sourcePath);
+          portalFiles.push(...files);
+          if (files.length > 0) {
+            gateConfig = await parseGateConfig(files[0]);
+            for (let i = 1; i < files.length; i++) {
+              const additional = await parseGateConfig(files[i]);
+              gateConfig.gates.push(...additional.gates);
+              gateConfig.flows.push(...additional.flows);
+            }
+          } else {
+            continue;
+          }
+        }
+        for (const gate of gateConfig.gates) {
+          symbols.push(createGateSymbol(gate, sourcePath));
+          for (const prize of gate.prizes) {
+            symbols.push(createSymbolEntry({
+              id: `gate-signal-${gate.id}-${prize.id}`,
+              symbol: `!${prize.id}`,
+              type: "signal",
+              source: "portal",
+              filePath: sourcePath,
+              data: prize,
+              description: `Signal from gate ${gate.id}`
+            }));
+          }
+        }
+        for (const flow of gateConfig.flows) {
+          symbols.push(createFlowSymbol(flow, sourcePath));
+        }
+      } catch (e) {
+        errors.push({
+          source: "portal",
+          filePath: sourcePath,
+          message: e.message
+        });
+      }
+    }
+  }
+  for (const node of premiseFile.nodes) {
+    const hasIdeaTag = node.tags?.includes("idea");
+    if (!node.content && !hasIdeaTag) {
+      const existing = symbols.find((s) => s.symbol === node.symbol);
+      if (existing) {
+        existing.position = node.position;
+        existing.tags = node.tags;
+        continue;
+      }
+    }
+    symbols.push(createSymbolEntry({
+      id: node.id,
+      symbol: node.symbol,
+      type: node.type,
+      source: "premise",
+      filePath: ".premise",
+      data: node,
+      description: node.content,
+      position: node.position,
+      tags: node.tags,
+      created: node.created,
+      modified: node.modified
+    }));
+  }
+  resolveReferences(symbols);
+  return {
+    symbols,
+    purposeFiles,
+    portalFiles,
+    errors,
+    timestamp: Date.now()
+  };
+}
+function createSymbolEntry(partial) {
+  return {
+    ...partial,
+    data: partial.data ?? null,
+    references: partial.references ?? [],
+    referencedBy: partial.referencedBy ?? []
+  };
+}
+function createGateSymbol(gate, filePath) {
+  return createSymbolEntry({
+    id: `gate-${gate.id}`,
+    symbol: `^${gate.id}`,
+    type: "gate",
+    source: "portal",
+    filePath,
+    data: gate,
+    description: gate.description,
+    position: gate.position
+  });
+}
+function createFlowSymbol(flow, filePath) {
+  return createSymbolEntry({
+    id: `gate-flow-${flow.id}`,
+    symbol: `$${flow.id}`,
+    type: "flow",
+    source: "portal",
+    filePath,
+    data: flow,
+    description: flow.description
+  });
+}
+function parseAnchorString(raw) {
+  const colonIndex = raw.lastIndexOf(":");
+  if (colonIndex === -1 || colonIndex === raw.length - 1) {
+    return { path: raw, lines: 0, raw };
+  }
+  const afterColon = raw.slice(colonIndex + 1);
+  const filePath = raw.slice(0, colonIndex);
+  if (!/^[\d,\- ]+$/.test(afterColon)) {
+    return { path: raw, lines: 0, raw };
+  }
+  if (afterColon.includes("-")) {
+    const [start, end] = afterColon.split("-").map(Number);
+    return { path: filePath, lines: [start, end], raw };
+  } else if (afterColon.includes(",")) {
+    const lines = afterColon.split(",").map(Number);
+    return { path: filePath, lines, raw };
+  } else {
+    return { path: filePath, lines: Number(afterColon), raw };
+  }
+}
+var SYMBOL_BLOCKLIST2 = /* @__PURE__ */ new Set([
+  "$lib",
+  "$env",
+  "$app",
+  "$service-worker",
+  "$virtual",
+  "$schema",
+  "$ref",
+  "$id",
+  "$type"
+]);
+function resolveReferences(symbols) {
+  const symbolMap = new Map(symbols.map((s) => [s.symbol, s]));
+  for (const symbol of symbols) {
+    const dataStr = JSON.stringify(symbol.data);
+    const refPattern = /(?:\?[@#$%~^!]|[@#$%~^!?])[a-zA-Z][\w-]*/g;
+    const matches = (dataStr.match(refPattern) || []).filter((m) => !SYMBOL_BLOCKLIST2.has(m));
+    for (const match of matches) {
+      if (match !== symbol.symbol && symbolMap.has(match)) {
+        if (!symbol.references.includes(match)) {
+          symbol.references.push(match);
+        }
+        const target = symbolMap.get(match);
+        if (target && !target.referencedBy.includes(symbol.symbol)) {
+          target.referencedBy.push(symbol.symbol);
+        }
+      }
+    }
+  }
+}
+async function aggregateFromDirectory(rootDir) {
+  const premiseFile = {
+    version: "1.0.0",
+    metadata: {
+      name: path3.basename(rootDir),
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    sources: {
+      purpose: [{ path: "./" }],
+      portal: [{ path: "./" }]
+    },
+    nodes: [],
+    connections: [],
+    layout: {
+      viewport: { x: 0, y: 0, zoom: 1 }
+    }
+  };
+  return aggregateFromPremise(premiseFile, rootDir);
+}
+function createSymbolIndex() {
+  return {
+    entries: /* @__PURE__ */ new Map(),
+    byType: /* @__PURE__ */ new Map(),
+    bySource: /* @__PURE__ */ new Map(),
+    timestamp: 0
+  };
+}
+function buildSymbolIndex(result) {
+  const index = createSymbolIndex();
+  index.timestamp = result.timestamp;
+  for (const symbol of result.symbols) {
+    index.entries.set(symbol.id, symbol);
+    if (!index.byType.has(symbol.type)) {
+      index.byType.set(symbol.type, []);
+    }
+    index.byType.get(symbol.type).push(symbol);
+    if (!index.bySource.has(symbol.source)) {
+      index.bySource.set(symbol.source, []);
+    }
+    index.bySource.get(symbol.source).push(symbol);
+  }
+  return index;
+}
+function getSymbol(index, symbol) {
+  for (const entry of index.entries.values()) {
+    if (entry.symbol === symbol) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+function getSymbolById(index, id) {
+  return index.entries.get(id);
+}
+function getSymbolsByType(index, type) {
+  return index.byType.get(type) || [];
+}
+function getSymbolsBySource(index, source) {
+  return index.bySource.get(source) || [];
+}
+function searchSymbols(index, query) {
+  const lowerQuery = query.toLowerCase();
+  const results = [];
+  for (const entry of index.entries.values()) {
+    if (entry.symbol.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
+    }
+    if (entry.description?.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
+    }
+    if (entry.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery))) {
+      results.push(entry);
+    }
+  }
+  return results;
+}
+function getReferencesTo(index, symbol) {
+  const entry = getSymbol(index, symbol);
+  if (!entry) return [];
+  return entry.referencedBy.map((ref) => getSymbol(index, ref)).filter((e) => e !== void 0);
+}
+function getReferencesFrom(index, symbol) {
+  const entry = getSymbol(index, symbol);
+  if (!entry) return [];
+  return entry.references.map((ref) => getSymbol(index, ref)).filter((e) => e !== void 0);
+}
+function getSymbolsByTag(index, tag) {
+  const results = [];
+  for (const entry of index.entries.values()) {
+    if (entry.tags?.includes(tag)) {
+      results.push(entry);
+    }
+  }
+  return results;
+}
+function getAllTags(index) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const entry of index.entries.values()) {
+    for (const tag of entry.tags || []) {
+      tags.add(tag);
+    }
+  }
+  return Array.from(tags).sort();
+}
+function getSymbolCounts(index) {
+  const counts = {
+    component: 0,
+    flow: 0,
+    gate: 0,
+    signal: 0,
+    aspect: 0
+  };
+  for (const [type, symbols] of index.byType) {
+    if (type in counts) {
+      counts[type] = symbols.length;
+    }
+  }
+  return counts;
+}
+function getAllSymbols(index) {
+  return Array.from(index.entries.values());
+}
+function parseSymbol(symbol) {
+  if (symbol.length < 2) return null;
+  const prefix = symbol[0];
+  const name = symbol.slice(1);
+  if (!isValidPrefix(prefix)) {
+    return null;
+  }
+  const type = PREFIX_TO_TYPE[prefix];
+  return { type, name };
+}
+function createSymbolString(type, name) {
+  return `${SYMBOL_PREFIXES[type]}${name}`;
+}
+function isValidSymbol(symbol) {
+  return parseSymbol(symbol) !== null;
+}
+function getAutocompleteSuggestions(index, partial, limit = 10) {
+  const lowerPartial = partial.toLowerCase();
+  const parsed = parseSymbol(partial);
+  if (parsed) {
+    const typeSymbols = getSymbolsByType(index, parsed.type);
+    return typeSymbols.filter((s) => s.symbol.toLowerCase().includes(lowerPartial)).slice(0, limit);
+  }
+  return searchSymbols(index, partial).slice(0, limit);
+}
+export {
+  PREFIX_TO_TYPE,
+  SYMBOL_PREFIXES,
+  addConnection,
+  addPremiseNode,
+  aggregateFromDirectory,
+  aggregateFromPremise,
+  buildSymbolIndex,
+  createEmptyPremiseFile,
+  createSnapshot,
+  createSymbolIndex,
+  createSymbolString,
+  getAllSymbols,
+  getAllTags,
+  getAutocompleteSuggestions,
+  getDefaultPremiseContent,
+  getReferencesFrom,
+  getReferencesTo,
+  getSymbol,
+  getSymbolById,
+  getSymbolCounts,
+  getSymbolsBySource,
+  getSymbolsByTag,
+  getSymbolsByType,
+  isValidSymbol,
+  parsePremiseContent,
+  parsePremiseFile,
+  parseSymbol,
+  searchSymbols,
+  serializePremiseFile,
+  updateNodePosition
+};