@c4a/core 0.4.12 → 0.4.15-alpha.2

package/README.md

@@ -0,0 +1,40 @@
+# @c4a/core
+
+`@c4a/core` is the shared foundation package for C4A. It provides reusable types, schemas, error definitions, and utility helpers used across multiple packages.
+
+## Installation
+
+```bash
+bun add @c4a/core
+# or
+npm install @c4a/core
+```
+
+## What It Includes
+
+- **Domain types**: common TypeScript types for entities, relations, contents, and sources
+- **Schema definitions**: Zod-based input/output validation models
+- **Error system**: unified error codes and `C4AError`
+- **Ref utilities**: helpers for parsing and building `ref:*` pointers
+- **Shared constants and helpers**: reusable utilities for API, CLI, Daemon, Web, and other packages
+
+## Example
+
+```ts
+import { C4AError, ErrorCode, parseRef } from "@c4a/core";
+
+const parsed = parseRef("ref:entity:ent_123");
+if (!parsed) {
+  throw new C4AError(ErrorCode.VALIDATION_FAILED, "Invalid ref");
+}
+```
+
+## Common Use Cases
+
+- Reuse a single contract across a monorepo to avoid type drift
+- Validate external inputs with consistent schemas and error handling
+- Parse and build cross-resource reference pointers
+
+## License
+
+MIT

package/index.js

@@ -7000,6 +7000,7 @@ var RelationType;
   RelationType2["Triggers"] = "TRIGGERS";
   RelationType2["References"] = "REFERENCES";
   RelationType2["Corresponds"] = "CORRESPONDS";
+  RelationType2["Mentions"] = "MENTIONS";
 })(RelationType ||= {});
 var AtomField;
 ((AtomField2) => {
@@ -7017,6 +7018,7 @@ var AtomField;
   AtomField2["Constraints"] = "constraints";
   AtomField2["Comparisons"] = "comparisons";
   AtomField2["Boundaries"] = "boundaries";
+  AtomField2["Claims"] = "claims";
 })(AtomField ||= {});
 var Kind;
 ((Kind2) => {
@@ -7029,12 +7031,124 @@ var Perspective;
   Perspective2["Business"] = "business";
   Perspective2["Technical"] = "technical";
 })(Perspective ||= {});
+// src/types/edgeSyncRules.ts
+var EDGE_SYNC_RULES = [
+  {
+    field: "container_id",
+    sourceEntityType: "component" /* Component */,
+    edgeType: "CONTAINS" /* Contains */,
+    direction: "reverse",
+    writeGraph: true
+  },
+  {
+    field: "system_id",
+    sourceEntityType: "container" /* Container */,
+    edgeType: "CONTAINS" /* Contains */,
+    direction: "reverse",
+    writeGraph: true
+  },
+  {
+    field: "ref_sor",
+    sourceEntityType: "sor" /* SoR */,
+    edgeType: "REFERENCES" /* References */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "product_refs",
+    sourceEntityType: "epic" /* Epic */,
+    edgeType: "REFERENCES" /* References */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "atoms.entities.ref",
+    sourceEntityType: "any",
+    edgeType: "MENTIONS" /* Mentions */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "atoms.behaviors.ref",
+    sourceEntityType: "any",
+    edgeType: "MENTIONS" /* Mentions */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "product_id",
+    sourceEntityType: "sor" /* SoR */,
+    edgeType: null,
+    direction: "forward",
+    writeGraph: false
+  },
+  {
+    field: "process_id",
+    sourceEntityType: "sor" /* SoR */,
+    edgeType: "PRODUCES" /* Produces */,
+    direction: "reverse",
+    writeGraph: true
+  }
+];
+// src/types/refPointer.ts
+var REF_POINTER_PATTERN = /^ref:(entity|relation|content):(.+)$/;
+function parseRef(pointer) {
+  const match = REF_POINTER_PATTERN.exec(pointer);
+  if (!match) {
+    return null;
+  }
+  const [, type, id] = match;
+  if (!id) {
+    return null;
+  }
+  return { type, id };
+}
+function buildRef(type, id) {
+  return `ref:${type}:${id}`;
+}
+function isRefPointer(value) {
+  return typeof value === "string" && parseRef(value) !== null;
+}
+function extractAllRefs(data) {
+  const results = [];
+  const visit = (value, path) => {
+    if (typeof value === "string") {
+      if (isRefPointer(value)) {
+        results.push({ pointer: value, fieldPath: path });
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        const nextPath = path ? `${path}[${index}]` : `[${index}]`;
+        visit(item, nextPath);
+      });
+      return;
+    }
+    if (value && typeof value === "object") {
+      for (const [key, entry] of Object.entries(value)) {
+        const nextPath = path ? `${path}.${key}` : key;
+        visit(entry, nextPath);
+      }
+    }
+  };
+  visit(data, "");
+  return results;
+}
 // src/types/serverConfig.ts
 var DEFAULT_SERVER_CONFIG = {
   server: {
     port: 5100,
     host: "::"
   },
+  git_hosts: [],
+  daemon_scheduler: {
+    enabled: true,
+    host: "localhost",
+    port: 5110,
+    workspace: "./data/daemon-workspace",
+    max_daemons: 20
+  },
   doc_db: {
     provider: "sqlite",
     sqlite: {
@@ -7057,6 +7171,9 @@ var DEFAULT_SERVER_CONFIG = {
       username: "root",
       password: "nebula",
       space: "c4a"
+    },
+    duckdb: {
+      path: "./data/c4a-graph.duckdb"
     }
   },
   vector_db: {
@@ -7078,7 +7195,8 @@ var DEFAULT_SERVER_CONFIG = {
     openai: {
       api_key: "",
       base_url: "",
-      default_model: "gpt-5.3-codex"
+      default_model: "gpt-5.3-codex",
+      wire_api: "chat"
     },
     anthropic: {
       api_key: "",
@@ -10753,23 +10871,23 @@ class ZodEffects extends ZodType {
     }
     if (effect.type === "transform") {
       if (ctx.common.async === false) {
-        const base2 = this._def.schema._parseSync({
+        const base = this._def.schema._parseSync({
           data: ctx.data,
           path: ctx.path,
           parent: ctx
         });
-        if (!isValid(base2))
+        if (!isValid(base))
           return INVALID;
-        const result = effect.transform(base2.value, checkCtx);
+        const result = effect.transform(base.value, checkCtx);
         if (result instanceof Promise) {
           throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
         }
         return { status: status.value, value: result };
       } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base2) => {
-          if (!isValid(base2))
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+          if (!isValid(base))
             return INVALID;
-          return Promise.resolve(effect.transform(base2.value, checkCtx)).then((result) => ({
+          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
             status: status.value,
             value: result
           }));
@@ -11158,7 +11276,7 @@ var atomFieldSchema = exports_external.enum(Object.values(AtomField));
 var kindSchema = exports_external.enum(Object.values(Kind));
 var scopeSchema = exports_external.literal("project");
 var perspectiveSchema = exports_external.enum(Object.values(Perspective));
-var confidenceSchema = exports_external.object({
+var extractionConfidenceSchema = exports_external.object({
   structural: exports_external.number().min(0).max(1),
   semantic: exports_external.number().min(0).max(1)
 });
@@ -11166,19 +11284,36 @@ var metadataSchema = exports_external.object({
   created_at: exports_external.string().datetime(),
   updated_at: exports_external.string().datetime(),
   version_tag: exports_external.string().optional(),
-  confidence: confidenceSchema.optional()
+  extraction_confidence: extractionConfidenceSchema.optional(),
+  confidence: exports_external.number().min(0).max(1).optional(),
+  aliases: exports_external.array(exports_external.string()).optional(),
+  rank: exports_external.number().optional(),
+  community_id: exports_external.string().optional(),
+  community_level: exports_external.number().optional()
+});
+var entityRefPointerSchema = exports_external.string().regex(/^ref:entity:.+$/, "must be a ref pointer in format ref:entity:<id>");
+var sourceRefSpanSchema = exports_external.object({
+  start: exports_external.number().int().min(1),
+  end: exports_external.number().int().min(1)
 });
+var sourceRefSchema = exports_external.object({
+  ref: exports_external.string(),
+  span: sourceRefSpanSchema.optional()
+});
+var sourceRefsSchema = exports_external.array(sourceRefSchema).optional();
+
 // src/schemas/atomsSchema.ts
 var confidenceAtomSchema = exports_external.number().min(0).max(1).optional();
 var entityAtomSchema = exports_external.object({
   name: exports_external.string(),
-  kind: kindSchema.optional(),
+  kind: kindSchema.optional().catch(undefined),
+  ref: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
 var relationAtomSchema = exports_external.object({
   from: exports_external.string(),
   to: exports_external.string(),
-  type: relationTypeSchema,
+  type: exports_external.string(),
   description: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
@@ -11186,6 +11321,8 @@ var behaviorAtomSchema = exports_external.object({
   name: exports_external.string(),
   signature: exports_external.string().optional(),
   description: exports_external.string().optional(),
+  performed_by: exports_external.array(exports_external.string()).optional(),
+  ref: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
 var attributeAtomSchema = exports_external.object({
@@ -11226,6 +11363,7 @@ var decisionPhaseSchema = exports_external.object({
   rationale: exports_external.string().optional()
 });
 var decisionAtomSchema = exports_external.object({
+  name: exports_external.string().optional(),
   description: exports_external.string(),
   rationale: exports_external.string(),
   alternatives: exports_external.array(exports_external.string()).optional(),
@@ -11248,13 +11386,13 @@ var metricAtomSchema = exports_external.object({
 });
 var roleAtomSchema = exports_external.object({
   name: exports_external.string(),
-  kind: exports_external.enum(["internal", "external"]),
+  kind: exports_external.enum(["human", "team", "persona"]).catch("human"),
   performs: exports_external.array(exports_external.string()).optional(),
-  confidence: confidenceAtomSchema
+  description: exports_external.string().optional()
 });
 var constraintAtomSchema = exports_external.object({
   description: exports_external.string(),
-  severity: exports_external.enum(["must", "should", "may"]),
+  severity: exports_external.enum(["must", "should", "may"]).catch("must"),
   metric_ref: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
@@ -11281,6 +11419,16 @@ var comparisonAtomSchema = exports_external.object({
   decision_ref: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
+var claimAtomSchema = exports_external.object({
+  claim_type: exports_external.string(),
+  description: exports_external.string(),
+  status: exports_external.enum(["active", "deprecated", "proposed"]),
+  valid_from: exports_external.string(),
+  valid_until: exports_external.string().optional(),
+  session_ref: exports_external.string().optional(),
+  changed_by: exports_external.string(),
+  confidence: confidenceAtomSchema
+});
 var dataAtomsSchema = exports_external.object({
   entities: exports_external.array(entityAtomSchema).optional(),
   relations: exports_external.array(relationAtomSchema).optional(),
@@ -11295,31 +11443,115 @@ var dataAtomsSchema = exports_external.object({
   roles: exports_external.array(roleAtomSchema).optional(),
   constraints: exports_external.array(constraintAtomSchema).optional(),
   comparisons: exports_external.array(comparisonAtomSchema).optional(),
-  boundaries: exports_external.array(boundaryAtomSchema).optional()
-}).superRefine((atoms2, ctx) => {
-  if (!atoms2.transitions || atoms2.transitions.length === 0) {
-    return;
-  }
+  boundaries: exports_external.array(boundaryAtomSchema).optional(),
+  claims: exports_external.array(claimAtomSchema).optional()
+}).superRefine((atoms, ctx) => {
   const stateValues = new Set;
-  for (const state of atoms2.states ?? []) {
+  const stateNames = new Set;
+  for (const state of atoms.states ?? []) {
+    stateNames.add(state.name);
     for (const value of state.values) {
       stateValues.add(value);
     }
   }
-  for (const transition of atoms2.transitions) {
-    if (!stateValues.has(transition.from)) {
-      ctx.addIssue({
-        code: exports_external.ZodIssueCode.custom,
-        path: ["transitions"],
-        message: `transition.from references unknown state: ${transition.from}`
-      });
+  const behaviorNames = new Set;
+  for (const behavior of atoms.behaviors ?? []) {
+    behaviorNames.add(behavior.name);
+  }
+  const roleNames = new Set;
+  for (const role of atoms.roles ?? []) {
+    roleNames.add(role.name);
+  }
+  const eventNames = new Set;
+  for (const event of atoms.events ?? []) {
+    eventNames.add(event.name);
+  }
+  const metricNames = new Set;
+  for (const metric of atoms.metrics ?? []) {
+    metricNames.add(metric.name);
+  }
+  if (atoms.transitions && atoms.transitions.length > 0) {
+    for (const transition of atoms.transitions) {
+      if (!stateValues.has(transition.from)) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          path: ["transitions"],
+          message: `transition.from references unknown state: ${transition.from}`
+        });
+      }
+      if (!stateValues.has(transition.to)) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          path: ["transitions"],
+          message: `transition.to references unknown state: ${transition.to}`
+        });
+      }
+      const hasEvents = eventNames.size > 0;
+      const hasBehaviors = behaviorNames.size > 0;
+      if (hasEvents || hasBehaviors) {
+        const triggerMatchesEvent = hasEvents && eventNames.has(transition.trigger);
+        const triggerMatchesBehavior = hasBehaviors && behaviorNames.has(transition.trigger);
+        if (!triggerMatchesEvent && !triggerMatchesBehavior) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["transitions"],
+            message: `transition.trigger references unknown event/behavior: ${transition.trigger}`
+          });
+        }
+      }
     }
-    if (!stateValues.has(transition.to)) {
-      ctx.addIssue({
-        code: exports_external.ZodIssueCode.custom,
-        path: ["transitions"],
-        message: `transition.to references unknown state: ${transition.to}`
-      });
+  }
+  if (atoms.roles && atoms.roles.length > 0) {
+    for (const [index, role] of atoms.roles.entries()) {
+      for (const perform of role.performs ?? []) {
+        if (!behaviorNames.has(perform)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["roles", index, "performs"],
+            message: `role.performs references unknown behavior: ${perform}`
+          });
+        }
+      }
+    }
+  }
+  if (atoms.behaviors && atoms.behaviors.length > 0) {
+    for (const [index, behavior] of atoms.behaviors.entries()) {
+      for (const performer of behavior.performed_by ?? []) {
+        if (!roleNames.has(performer)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["behaviors", index, "performed_by"],
+            message: `behavior.performed_by references unknown role: ${performer}`
+          });
+        }
+      }
+    }
+  }
+  if (atoms.rules && atoms.rules.length > 0) {
+    const allowedDependsOn = new Set([...stateNames, ...metricNames]);
+    for (const [index, rule] of atoms.rules.entries()) {
+      for (const dependency of rule.depends_on ?? []) {
+        if (!allowedDependsOn.has(dependency)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["rules", index, "depends_on"],
+            message: `rule.depends_on references unknown state/metric: ${dependency}`
+          });
+        }
+      }
+    }
+  }
+  if (atoms.events && atoms.events.length > 0) {
+    for (const [index, event] of atoms.events.entries()) {
+      for (const behaviorName of event.trigger_for ?? []) {
+        if (!behaviorNames.has(behaviorName)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["events", index, "trigger_for"],
+            message: `event.trigger_for references unknown behavior: ${behaviorName}`
+          });
+        }
+      }
     }
   }
 });
@@ -11335,7 +11567,8 @@ var atomsWhitelistByEntityType = {
     "states" /* States */,
     "rules" /* Rules */,
     "transitions" /* Transitions */,
-    "events" /* Events */
+    "events" /* Events */,
+    "claims" /* Claims */
   ]),
   ["process" /* Process */]: new Set,
   ["sor" /* SoR */]: new Set([
@@ -11351,7 +11584,8 @@ var atomsWhitelistByEntityType = {
     "metrics" /* Metrics */,
     "roles" /* Roles */,
     "constraints" /* Constraints */,
-    "comparisons" /* Comparisons */
+    "comparisons" /* Comparisons */,
+    "claims" /* Claims */
   ]),
   ["contract" /* Contract */]: new Set,
   ["epic" /* Epic */]: new Set([
@@ -11359,15 +11593,16 @@ var atomsWhitelistByEntityType = {
     "metrics" /* Metrics */,
     "roles" /* Roles */,
     "constraints" /* Constraints */,
-    "comparisons" /* Comparisons */
+    "comparisons" /* Comparisons */,
+    "claims" /* Claims */
   ]),
   ["document" /* Document */]: new Set
 };
 var allowedAtomFieldSchema = atomFieldSchema;
-var validateAtomsWhitelist = (entityType, atoms2) => {
+var validateAtomsWhitelist = (entityType, atoms) => {
   const allowed = atomsWhitelistByEntityType[entityType] ?? new Set;
   const illegalFields = [];
-  for (const [key, value] of Object.entries(atoms2)) {
+  for (const [key, value] of Object.entries(atoms)) {
     if (value === undefined) {
       continue;
     }
@@ -11377,6 +11612,60 @@ var validateAtomsWhitelist = (entityType, atoms2) => {
   }
   return illegalFields;
 };
+
+// src/types/docDigest.ts
+var paragraphAtomSchema = exports_external.object({
+  entities: exports_external.array(entityAtomSchema).optional(),
+  relations: exports_external.array(relationAtomSchema).optional(),
+  behaviors: exports_external.array(behaviorAtomSchema).optional(),
+  attributes: exports_external.array(attributeAtomSchema).optional(),
+  states: exports_external.array(stateAtomSchema).optional(),
+  rules: exports_external.array(ruleAtomSchema).optional(),
+  transitions: exports_external.array(transitionAtomSchema).optional(),
+  events: exports_external.array(eventAtomSchema).optional(),
+  decisions: exports_external.array(decisionAtomSchema).optional(),
+  metrics: exports_external.array(metricAtomSchema).optional(),
+  roles: exports_external.array(roleAtomSchema).optional(),
+  constraints: exports_external.array(constraintAtomSchema).optional(),
+  comparisons: exports_external.array(comparisonAtomSchema).optional(),
+  boundaries: exports_external.array(boundaryAtomSchema).optional()
+});
+var docParagraphSchema = exports_external.object({
+  text: exports_external.string(),
+  atoms: paragraphAtomSchema
+});
+var sectionSchema = exports_external.object({
+  heading: exports_external.string(),
+  level: exports_external.number().int().min(0).max(6),
+  paragraphs: exports_external.array(docParagraphSchema)
+});
+var embeddingEntrySchema = exports_external.object({
+  sectionIndex: exports_external.number().int(),
+  paragraphIndex: exports_external.number().int(),
+  vector: exports_external.array(exports_external.number())
+});
+var docDigestSchema = exports_external.object({
+  version: exports_external.literal("1"),
+  sections: exports_external.array(sectionSchema),
+  embeddings: exports_external.array(embeddingEntrySchema),
+  metadata: exports_external.object({
+    sourceId: exports_external.string(),
+    hashId: exports_external.string(),
+    sourcePath: exports_external.string(),
+    contentHash: exports_external.string(),
+    chunkCount: exports_external.number().int(),
+    totalTokens: exports_external.number().int(),
+    llmCalls: exports_external.number().int(),
+    processedAt: exports_external.string()
+  })
+});
+var docChunkParagraphSchema = exports_external.object({
+  tag: exports_external.string().regex(/^P\d+$/),
+  atoms: paragraphAtomSchema
+});
+var docChunkResultSchema = exports_external.object({
+  paragraphs: exports_external.array(docChunkParagraphSchema)
+});
 // src/schemas/entitySchema.ts
 var baseEntitySchema = exports_external.object({
   id: exports_external.string(),
@@ -11385,7 +11674,8 @@ var baseEntitySchema = exports_external.object({
   kind: kindSchema,
   scope: scopeSchema,
   perspective: perspectiveSchema,
-  metadata: metadataSchema
+  metadata: metadataSchema,
+  source_refs: sourceRefsSchema
 });
 var productDataSchema = exports_external.object({
   description: exports_external.string().optional(),
@@ -11399,7 +11689,8 @@ var productEntitySchema = baseEntitySchema.extend({
 });
 var systemDataSchema = exports_external.object({
   description: exports_external.string().optional(),
-  corresponds_to: exports_external.string().optional()
+  corresponds_to: exports_external.string().optional(),
+  atoms: exports_external.undefined().optional()
 });
 var systemEntitySchema = baseEntitySchema.extend({
   type: exports_external.literal("system" /* System */),
@@ -11445,9 +11736,10 @@ var sorEntitySchema = baseEntitySchema.extend({
   data: sorDataSchema
 });
 var contractDataSchema = exports_external.object({
-  format: exports_external.enum(["openapi", "asyncapi", "proto"]),
+  format: exports_external.enum(["openapi", "asyncapi", "proto", "graphql", "custom"]),
   spec: exports_external.string(),
-  component_id: exports_external.string().optional()
+  version: exports_external.string().optional(),
+  description: exports_external.string().optional()
 });
 var contractEntitySchema = baseEntitySchema.extend({
   type: exports_external.literal("contract" /* Contract */),
@@ -11455,7 +11747,7 @@ var contractEntitySchema = baseEntitySchema.extend({
 });
 var epicDataSchema = exports_external.object({
   description: exports_external.string().optional(),
-  product_refs: exports_external.array(exports_external.string()).optional(),
+  product_refs: exports_external.array(entityRefPointerSchema).optional(),
   atoms: dataAtomsSchema.optional()
 });
 var epicEntitySchema = baseEntitySchema.extend({
@@ -11531,18 +11823,45 @@ var entitySchema = exports_external.discriminatedUnion("type", [
       });
     }
   }
+  if (entity2.type === "sor" /* SoR */ && entity2.data.atoms) {
+    const { constraints, rules } = entity2.data.atoms;
+    const hasConstraints = Array.isArray(constraints) && constraints.length > 0;
+    const hasRules = Array.isArray(rules) && rules.length > 0;
+    if (!hasConstraints && !hasRules) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["data", "atoms"],
+        message: "SoR must have at least one constraint or rule"
+      });
+    }
+  }
+  if (entity2.type === "epic" /* Epic */ && entity2.data.atoms) {
+    const { decisions } = entity2.data.atoms;
+    const hasDecisions = Array.isArray(decisions) && decisions.length > 0;
+    if (!hasDecisions) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["data", "atoms"],
+        message: "Epic must have at least one decision"
+      });
+    }
+  }
 });
 // src/schemas/relationSchema.ts
 var relationDataSchema = exports_external.object({
-  description: exports_external.string().optional()
+  description: exports_external.string().optional(),
+  _source: exports_external.literal("field_sync").optional()
 });
 var relationSchema = exports_external.object({
   id: exports_external.string(),
   type: relationTypeSchema,
   from: exports_external.string(),
   to: exports_external.string(),
+  weight: exports_external.number().optional(),
+  confidence: exports_external.number().min(0).max(1).optional(),
   data: relationDataSchema.optional(),
-  metadata: metadataSchema.optional()
+  metadata: metadataSchema.optional(),
+  source_refs: sourceRefsSchema
 });
 // src/errors/c4aError.ts
 class C4AError extends Error {
@@ -11590,8 +11909,36 @@ var ErrorCode;
   ErrorCode2["LLM_NOT_AVAILABLE"] = "LLM_NOT_AVAILABLE";
   ErrorCode2["LLM_CALL_FAILED"] = "LLM_CALL_FAILED";
   ErrorCode2["LLM_AUTH_FAILED"] = "LLM_AUTH_FAILED";
+  ErrorCode2["AUTH_REQUIRED"] = "AUTH_REQUIRED";
+  ErrorCode2["AUTH_INVALID_TOKEN"] = "AUTH_INVALID_TOKEN";
+  ErrorCode2["AUTH_INVALID_API_KEY"] = "AUTH_INVALID_API_KEY";
+  ErrorCode2["AUTH_PROVIDER_ERROR"] = "AUTH_PROVIDER_ERROR";
+  ErrorCode2["AUTH_RESERVED_NAME"] = "AUTH_RESERVED_NAME";
+  ErrorCode2["DAEMON_OFFLINE"] = "DAEMON_OFFLINE";
+  ErrorCode2["SOURCE_NOT_FOUND"] = "SOURCE_NOT_FOUND";
+  ErrorCode2["REPO_PATH_NOT_FOUND"] = "REPO_PATH_NOT_FOUND";
+  ErrorCode2["COMMIT_NOT_FOUND"] = "COMMIT_NOT_FOUND";
+  ErrorCode2["INDEX_IN_PROGRESS"] = "INDEX_IN_PROGRESS";
+  ErrorCode2["DIGEST_NOT_FOUND"] = "DIGEST_NOT_FOUND";
+  ErrorCode2["INVALID_REGEX"] = "INVALID_REGEX";
+  ErrorCode2["SOURCE_ACCESS_DENIED"] = "SOURCE_ACCESS_DENIED";
+  ErrorCode2["WORKSPACE_ISOLATION"] = "WORKSPACE_ISOLATION";
   ErrorCode2["VECTOR_DIMENSION_MISMATCH"] = "VECTOR_DIMENSION_MISMATCH";
   ErrorCode2["VECTOR_REBUILD_PARTIAL"] = "VECTOR_REBUILD_PARTIAL";
+  ErrorCode2["COMMIT_NOT_AVAILABLE"] = "COMMIT_NOT_AVAILABLE";
+  ErrorCode2["DAEMON_AUTO_START_FAILED"] = "DAEMON_AUTO_START_FAILED";
+  ErrorCode2["GIT_ARCHIVE_FAILED"] = "GIT_ARCHIVE_FAILED";
+  ErrorCode2["GIT_HOST_NOT_CONFIGURED"] = "GIT_HOST_NOT_CONFIGURED";
+  ErrorCode2["GIT_API_RATE_LIMITED"] = "GIT_API_RATE_LIMITED";
+  ErrorCode2["GIT_API_TREE_TRUNCATED"] = "GIT_API_TREE_TRUNCATED";
+  ErrorCode2["GIT_API_AUTH_FAILED"] = "GIT_API_AUTH_FAILED";
+  ErrorCode2["GIT_API_REPO_NOT_FOUND"] = "GIT_API_REPO_NOT_FOUND";
+  ErrorCode2["GIT_API_NETWORK_ERROR"] = "GIT_API_NETWORK_ERROR";
+  ErrorCode2["DOC_INDEX_LLM_UNAVAILABLE"] = "DOC_INDEX_LLM_UNAVAILABLE";
+  ErrorCode2["DOC_INDEX_EMBEDDING_UNAVAILABLE"] = "DOC_INDEX_EMBEDDING_UNAVAILABLE";
+  ErrorCode2["DOC_INDEX_CONTENT_MISSING"] = "DOC_INDEX_CONTENT_MISSING";
+  ErrorCode2["DOC_INDEX_PARSE_FAILED"] = "DOC_INDEX_PARSE_FAILED";
+  ErrorCode2["DOC_INDEX_LLM_EXHAUSTED"] = "DOC_INDEX_LLM_EXHAUSTED";
   ErrorCode2["UNKNOWN"] = "UNKNOWN";
 })(ErrorCode ||= {});
 // src/errors/httpStatus.ts
@@ -11602,29 +11949,57 @@ var ERROR_CODE_HTTP_STATUS = {
   ["PARSE_YAML" /* PARSE_YAML */]: 400,
   ["RELATION_INVALID" /* RELATION_INVALID */]: 400,
   ["QUERY_INVALID_PARAMS" /* QUERY_INVALID_PARAMS */]: 400,
+  ["INVALID_REGEX" /* INVALID_REGEX */]: 400,
   ["BACKUP_VERSION_INCOMPATIBLE" /* BACKUP_VERSION_INCOMPATIBLE */]: 400,
   ["BACKUP_MANIFEST_INVALID" /* BACKUP_MANIFEST_INVALID */]: 400,
   ["VECTOR_DIMENSION_MISMATCH" /* VECTOR_DIMENSION_MISMATCH */]: 400,
   ["STORAGE_NOT_FOUND" /* STORAGE_NOT_FOUND */]: 404,
   ["ENTITY_NOT_FOUND" /* ENTITY_NOT_FOUND */]: 404,
   ["BACKUP_DIR_NOT_FOUND" /* BACKUP_DIR_NOT_FOUND */]: 404,
+  ["SOURCE_NOT_FOUND" /* SOURCE_NOT_FOUND */]: 404,
+  ["DIGEST_NOT_FOUND" /* DIGEST_NOT_FOUND */]: 404,
   ["STORAGE_CONFLICT" /* STORAGE_CONFLICT */]: 409,
   ["ENTITY_DUPLICATE" /* ENTITY_DUPLICATE */]: 409,
+  ["INDEX_IN_PROGRESS" /* INDEX_IN_PROGRESS */]: 409,
   ["API_UNAUTHORIZED" /* API_UNAUTHORIZED */]: 401,
   ["LLM_AUTH_FAILED" /* LLM_AUTH_FAILED */]: 401,
+  ["AUTH_REQUIRED" /* AUTH_REQUIRED */]: 401,
+  ["AUTH_INVALID_TOKEN" /* AUTH_INVALID_TOKEN */]: 401,
+  ["AUTH_INVALID_API_KEY" /* AUTH_INVALID_API_KEY */]: 401,
+  ["AUTH_RESERVED_NAME" /* AUTH_RESERVED_NAME */]: 400,
+  ["SOURCE_ACCESS_DENIED" /* SOURCE_ACCESS_DENIED */]: 403,
+  ["REPO_PATH_NOT_FOUND" /* REPO_PATH_NOT_FOUND */]: 422,
+  ["COMMIT_NOT_FOUND" /* COMMIT_NOT_FOUND */]: 422,
+  ["COMMIT_NOT_AVAILABLE" /* COMMIT_NOT_AVAILABLE */]: 422,
+  ["GIT_HOST_NOT_CONFIGURED" /* GIT_HOST_NOT_CONFIGURED */]: 422,
+  ["GIT_API_TREE_TRUNCATED" /* GIT_API_TREE_TRUNCATED */]: 422,
   ["API_RATE_LIMITED" /* API_RATE_LIMITED */]: 429,
+  ["GIT_API_RATE_LIMITED" /* GIT_API_RATE_LIMITED */]: 429,
   ["API_NOT_IMPLEMENTED" /* API_NOT_IMPLEMENTED */]: 501,
   ["BATCH_PARTIAL_FAILURE" /* BATCH_PARTIAL_FAILURE */]: 200,
   ["VECTOR_REBUILD_PARTIAL" /* VECTOR_REBUILD_PARTIAL */]: 200,
   ["STORAGE_FAILED" /* STORAGE_FAILED */]: 500,
   ["EMBEDDING_FAILED" /* EMBEDDING_FAILED */]: 500,
   ["LLM_CALL_FAILED" /* LLM_CALL_FAILED */]: 500,
+  ["GIT_API_NETWORK_ERROR" /* GIT_API_NETWORK_ERROR */]: 502,
   ["BACKUP_FAILED" /* BACKUP_FAILED */]: 500,
   ["RESTORE_FAILED" /* RESTORE_FAILED */]: 500,
   ["PURGE_FAILED" /* PURGE_FAILED */]: 500,
+  ["GIT_ARCHIVE_FAILED" /* GIT_ARCHIVE_FAILED */]: 500,
   ["EMBEDDING_NOT_AVAILABLE" /* EMBEDDING_NOT_AVAILABLE */]: 503,
   ["LLM_NOT_AVAILABLE" /* LLM_NOT_AVAILABLE */]: 503,
-  ["UNKNOWN" /* UNKNOWN */]: 500
+  ["DAEMON_OFFLINE" /* DAEMON_OFFLINE */]: 503,
+  ["DAEMON_AUTO_START_FAILED" /* DAEMON_AUTO_START_FAILED */]: 503,
+  ["GIT_API_AUTH_FAILED" /* GIT_API_AUTH_FAILED */]: 502,
+  ["GIT_API_REPO_NOT_FOUND" /* GIT_API_REPO_NOT_FOUND */]: 404,
+  ["AUTH_PROVIDER_ERROR" /* AUTH_PROVIDER_ERROR */]: 502,
+  ["DOC_INDEX_LLM_UNAVAILABLE" /* DOC_INDEX_LLM_UNAVAILABLE */]: 503,
+  ["DOC_INDEX_EMBEDDING_UNAVAILABLE" /* DOC_INDEX_EMBEDDING_UNAVAILABLE */]: 503,
+  ["DOC_INDEX_CONTENT_MISSING" /* DOC_INDEX_CONTENT_MISSING */]: 404,
+  ["DOC_INDEX_PARSE_FAILED" /* DOC_INDEX_PARSE_FAILED */]: 422,
+  ["DOC_INDEX_LLM_EXHAUSTED" /* DOC_INDEX_LLM_EXHAUSTED */]: 502,
+  ["UNKNOWN" /* UNKNOWN */]: 500,
+  ["WORKSPACE_ISOLATION" /* WORKSPACE_ISOLATION */]: 400
 };
 function mapErrorCodeToStatus(code) {
   return ERROR_CODE_HTTP_STATUS[code] ?? 500;
@@ -11681,31 +12056,134 @@ function parseYaml(value) {
   }
 }
 // src/constants.ts
-var DEFAULT_USER_ID = "user_admin";
-var DEFAULT_USER_NAME = "admin";
-var DEFAULT_WORKSPACE_ID = "ws_default";
-var DEFAULT_WORKSPACE_NAME = "默认大脑";
-var DEFAULT_CLOUD_LIBRARY_ID = "lib_cloud_default";
-var DEFAULT_CLOUD_LIBRARY_NAME = "个人云";
+var DEFAULT_WORKSPACE_NAME = "My Brain";
+var DEFAULT_CLOUD_LIBRARY_NAME = "My Drive";
+var SUPERTEST_EMAIL = "supertest@context4ai.org";
+var SUPERTEST_USER_NAME = "SuperTest";
+var RESERVED_USER_NAMES = ["SuperTest"];
 var DAEMON_HEARTBEAT_INTERVAL = 30000;
 var DAEMON_OFFLINE_THRESHOLD = 60000;
+var CLOUD_DAEMON_IDLE_TIMEOUT = 300000;
+// src/contentTypeRegistry.ts
+var DEFAULT_CONTENT_TYPES = [
+  {
+    id: "markdown",
+    category: "doc",
+    match: { extensions: [".md", ".txt"] },
+    cas: { encoding: "utf8", hashInput: "content" },
+    pipeline: { digest: ["summary", "outline"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCC4", renderer: "text" }
+  },
+  {
+    id: "typescript",
+    category: "code",
+    match: { extensions: [".ts", ".tsx"] },
+    cas: { encoding: "utf8", hashInput: "content" },
+    pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCDC", renderer: "code" }
+  },
+  {
+    id: "package",
+    category: "package",
+    match: { filenames: ["package.json", "go.mod", "pyproject.toml", "Cargo.toml", "pom.xml"] },
+    cas: { encoding: "utf8", hashInput: "identity" },
+    pipeline: { digest: ["summary"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCE6", renderer: "package-card" }
+  },
+  {
+    id: "pdf",
+    category: "binary",
+    match: { extensions: [".pdf"] },
+    cas: { encoding: "base64", hashInput: "content" },
+    pipeline: { digest: [], extraction: [] },
+    display: { icon: "\uD83D\uDCD5", renderer: "binary-preview" }
+  },
+  {
+    id: "msword",
+    category: "binary",
+    match: { extensions: [".doc", ".docx"] },
+    cas: { encoding: "base64", hashInput: "content" },
+    pipeline: { digest: [], extraction: [] },
+    display: { icon: "\uD83D\uDCD8", renderer: "binary-preview" }
+  },
+  {
+    id: "mspowerpoint",
+    category: "binary",
+    match: { extensions: [".ppt", ".pptx"] },
+    cas: { encoding: "base64", hashInput: "content" },
+    pipeline: { digest: [], extraction: [] },
+    display: { icon: "\uD83D\uDCD9", renderer: "binary-preview" }
+  }
+];
+var normalizeExtension = (ext) => ext.trim().toLowerCase();
+var normalizeFilename = (name) => name.trim().toLowerCase();
+
+class ContentTypeRegistry {
+  definitions;
+  extensionIndex;
+  filenameIndex;
+  constructor(definitions) {
+    this.definitions = definitions;
+    this.extensionIndex = new Map;
+    this.filenameIndex = new Map;
+    for (const def of definitions) {
+      for (const ext of def.match.extensions ?? []) {
+        this.extensionIndex.set(normalizeExtension(ext), def);
+      }
+      for (const name of def.match.filenames ?? []) {
+        this.filenameIndex.set(normalizeFilename(name), def);
+      }
+    }
+  }
+  resolve(filename) {
+    const baseName = filename.includes("/") ? filename.split("/").pop() ?? filename : filename;
+    const normalized = normalizeFilename(baseName);
+    const byName = this.filenameIndex.get(normalized);
+    if (byName)
+      return byName;
+    const dot = normalized.lastIndexOf(".");
+    if (dot < 0)
+      return null;
+    const ext = normalizeExtension(normalized.slice(dot));
+    return this.extensionIndex.get(ext) ?? null;
+  }
+  getManifestFilenames() {
+    const names = new Set;
+    for (const def of this.definitions) {
+      if (def.category !== "package")
+        continue;
+      for (const name of def.match.filenames ?? []) {
+        names.add(normalizeFilename(name));
+      }
+    }
+    return Array.from(names);
+  }
+  getDefinitions() {
+    return [...this.definitions];
+  }
+}
+var defaultRegistry = new ContentTypeRegistry(DEFAULT_CONTENT_TYPES);
+var DEFAULT_CONTENT_TYPE_DEFINITIONS = DEFAULT_CONTENT_TYPES;
 // src/fileTypes.ts
-var INDEXABLE_CODE_EXTENSIONS = new Set([".ts", ".tsx"]);
-var INDEXABLE_DOC_EXTENSIONS = new Set([".md"]);
+var collectExtensions = (predicate) => {
+  const extensions = new Set;
+  for (const definition of DEFAULT_CONTENT_TYPE_DEFINITIONS) {
+    if (!predicate(definition))
+      continue;
+    for (const ext of definition.match.extensions ?? []) {
+      extensions.add(ext.toLowerCase());
+    }
+  }
+  return extensions;
+};
+var INDEXABLE_CODE_EXTENSIONS = collectExtensions((definition) => definition.category === "code");
+var INDEXABLE_DOC_EXTENSIONS = collectExtensions((definition) => definition.category === "doc");
 var INDEXABLE_EXTENSIONS = new Set([
   ...INDEXABLE_CODE_EXTENSIONS,
   ...INDEXABLE_DOC_EXTENSIONS
 ]);
-var UPLOAD_ALLOWED_EXTENSIONS = new Set([
-  ".md",
-  ".doc",
-  ".docx",
-  ".pdf",
-  ".ppt",
-  ".pptx",
-  ".txt"
-]);
-var TEXT_EXTENSIONS = new Set([".md", ".txt"]);
+var UPLOAD_ALLOWED_EXTENSIONS = collectExtensions(() => true);
+var TEXT_EXTENSIONS = collectExtensions((definition) => definition.cas.encoding === "utf8");
 var UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
 var UPLOAD_MAX_FILES = 10;
 function getFileExtension(name) {
@@ -11714,10 +12192,7 @@ function getFileExtension(name) {
 }
 function isIndexableFile(fileName, manifestFiles) {
   const baseName = fileName.includes("/") ? fileName.split("/").pop() : fileName;
-  if (manifestFiles.has(baseName.toLowerCase()))
-    return true;
-  const ext = getFileExtension(baseName);
-  return INDEXABLE_EXTENSIONS.has(ext);
+  return defaultRegistry.resolve(baseName) !== null;
 }
 // src/wsEvents.ts
 var WS_SESSION_STATUS = "ws:session:status";
@@ -11728,14 +12203,22 @@ var WS_DAEMON_CONNECTED = "ws:daemon:connected";
 var WS_DAEMON_STATUS = "ws:daemon:status";
 var WS_DAEMON_HEARTBEAT = "ws:daemon:heartbeat";
 var WS_LIBRARY_UPDATED = "ws:library:updated";
+var WS_INDEX_PROGRESS = "index/progress";
+var WS_INDEX_DONE = "index/done";
+var WS_INDEX_ERROR = "index/error";
+var WS_INDEX_TIMEOUT = "index/timeout";
 export {
   validateAtomsWhitelist,
   transitionAtomSchema,
   systemEntitySchema,
   stateAtomSchema,
+  sourceRefsSchema,
+  sourceRefSpanSchema,
+  sourceRefSchema,
   sorEntitySchema,
   sessionDecisionSchema,
   serializeYaml,
+  sectionSchema,
   scopeSchema,
   ruleAtomSchema,
   roleAtomSchema,
@@ -11747,6 +12230,8 @@ export {
   processEntitySchema,
   perspectiveSchema,
   parseYaml,
+  parseRef,
+  paragraphAtomSchema,
   modelingSessionDataSchema,
   metricMilestoneSchema,
   metricAtomSchema,
@@ -11754,32 +12239,43 @@ export {
   mapErrorCodeToStatus,
   kindSchema,
   isValidManifest,
+  isRefPointer,
   isPathSafe,
   isIndexableFile,
   getFileExtension,
   generateUUID,
   generateId,
+  extractionConfidenceSchema,
+  extractAllRefs,
   eventAtomSchema,
   epicEntitySchema,
   entityTypeSchema,
   entitySchema,
+  entityRefPointerSchema,
   entityAtomSchema,
+  embeddingEntrySchema,
   documentSchema,
   documentModelingEntitySchema,
   documentEntitySchema,
   documentAdrEntitySchema,
+  docDigestSchema,
+  docChunkResultSchema,
+  docChunkParagraphSchema,
+  defaultRegistry,
   decisionPhaseSchema,
   decisionAtomSchema,
   dataAtomsSchema,
   contractEntitySchema,
+  contractDataSchema,
   contentHash,
   containerEntitySchema,
   constraintAtomSchema,
-  confidenceSchema,
   componentEntitySchema,
   comparisonDimensionValueSchema,
   comparisonDimensionSchema,
   comparisonAtomSchema,
+  claimAtomSchema,
+  buildRef,
   boundaryAtomSchema,
   behaviorAtomSchema,
   attributeAtomSchema,
@@ -11790,6 +12286,10 @@ export {
   WS_SESSION_STATUS,
   WS_SESSION_PROGRESS,
   WS_LIBRARY_UPDATED,
+  WS_INDEX_TIMEOUT,
+  WS_INDEX_PROGRESS,
+  WS_INDEX_ERROR,
+  WS_INDEX_DONE,
   WS_DAEMON_STATUS,
   WS_DAEMON_HEARTBEAT,
   WS_DAEMON_HANDSHAKE_ACK,
@@ -11799,7 +12299,10 @@ export {
   UPLOAD_MAX_FILES,
   UPLOAD_ALLOWED_EXTENSIONS,
   TEXT_EXTENSIONS,
+  SUPERTEST_USER_NAME,
+  SUPERTEST_EMAIL,
   RelationType,
+  RESERVED_USER_NAMES,
   Perspective,
   Kind,
   INDEXABLE_EXTENSIONS,
@@ -11807,16 +12310,16 @@ export {
   INDEXABLE_CODE_EXTENSIONS,
   ErrorCode,
   EntityType,
+  EDGE_SYNC_RULES,
   DEFAULT_WORKSPACE_NAME,
-  DEFAULT_WORKSPACE_ID,
-  DEFAULT_USER_NAME,
-  DEFAULT_USER_ID,
   DEFAULT_SERVER_CONFIG,
+  DEFAULT_CONTENT_TYPE_DEFINITIONS,
   DEFAULT_CLOUD_LIBRARY_NAME,
-  DEFAULT_CLOUD_LIBRARY_ID,
   DAEMON_OFFLINE_THRESHOLD,
   DAEMON_HEARTBEAT_INTERVAL,
+  ContentTypeRegistry,
   CODE_PACKAGE_FILES,
+  CLOUD_DAEMON_IDLE_TIMEOUT,
   C4AError,
   AtomField
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/core",
-  "version": "0.4.12",
+  "version": "0.4.15-alpha.2",
   "type": "module",
   "dependencies": {
     "yaml": "^2.4.5",