@a-company/paradigm 5.11.0 → 5.21.0

package/dist/dist-OGTSAZ55.js

@@ -1,1358 +0,0 @@
-#!/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(),
-  // Component type and hierarchy (v4)
-  type: z.string().optional(),
-  parent: z.string().optional(),
-  anchors: z.array(z.string()).optional(),
-  tags: z.array(z.string()).optional(),
-  // Standard fields
-  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
-  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) {
-          const featureTags = ["feature", ...item.tags || []];
-          symbols.push(createSymbolEntry({
-            id: `purpose-feature-${id}`,
-            symbol: `#${id}`,
-            type: "component",
-            source: "purpose",
-            filePath,
-            data: item,
-            description: item.description,
-            tags: featureTags,
-            componentType: item.type,
-            parentSymbol: item.parent,
-            anchors: item.anchors?.map((a) => parseAnchorString(a))
-          }));
-        }
-        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,
-            tags: item.tags,
-            componentType: item.type,
-            parentSymbol: item.parent,
-            anchors: item.anchors?.map((a) => parseAnchorString(a))
-          }));
-        }
-        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);
-  const symbolFileMap = /* @__PURE__ */ new Map();
-  for (const sym of symbols) {
-    const files = symbolFileMap.get(sym.symbol) || [];
-    if (!files.includes(sym.filePath)) {
-      files.push(sym.filePath);
-    }
-    symbolFileMap.set(sym.symbol, files);
-  }
-  const duplicateSymbols = [];
-  for (const [symbol, files] of symbolFileMap) {
-    if (files.length > 1) {
-      duplicateSymbols.push({ symbol, files });
-    }
-  }
-  return {
-    symbols,
-    purposeFiles,
-    portalFiles,
-    errors,
-    timestamp: Date.now(),
-    ...duplicateSymbols.length > 0 ? { duplicateSymbols } : {}
-  };
-}
-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);
-      continue;
-    }
-    if (entry.componentType?.toLowerCase().includes(lowerQuery)) {
-      results.push(entry);
-      continue;
-    }
-  }
-  return results;
-}
-function getComponentsByType(index, componentType) {
-  const components = getSymbolsByType(index, "component");
-  return components.filter((c) => c.componentType === componentType);
-}
-function getAllComponentTypes(index) {
-  const types = /* @__PURE__ */ new Set();
-  const components = getSymbolsByType(index, "component");
-  for (const comp of components) {
-    if (comp.componentType) {
-      types.add(comp.componentType);
-    }
-  }
-  return Array.from(types).sort();
-}
-function getChildComponents(index, parentSymbol) {
-  const components = getSymbolsByType(index, "component");
-  return components.filter((c) => c.parentSymbol === parentSymbol);
-}
-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,
-  getAllComponentTypes,
-  getAllSymbols,
-  getAllTags,
-  getAutocompleteSuggestions,
-  getChildComponents,
-  getComponentsByType,
-  getDefaultPremiseContent,
-  getReferencesFrom,
-  getReferencesTo,
-  getSymbol,
-  getSymbolById,
-  getSymbolCounts,
-  getSymbolsBySource,
-  getSymbolsByTag,
-  getSymbolsByType,
-  isValidSymbol,
-  parsePremiseContent,
-  parsePremiseFile,
-  parseSymbol,
-  searchSymbols,
-  serializePremiseFile,
-  updateNodePosition
-};