@c4a/core 0.4.12-beta.7 → 0.4.15-alpha.1

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

@@ -7195,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: "",
@@ -10870,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
           }));
@@ -11300,18 +11301,19 @@ var sourceRefSchema = exports_external.object({
   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
 });
@@ -11384,13 +11386,13 @@ var metricAtomSchema = exports_external.object({
 });
 var roleAtomSchema = exports_external.object({
   name: exports_external.string(),
-  kind: exports_external.enum(["human", "team", "persona"]),
+  kind: exports_external.enum(["human", "team", "persona"]).catch("human"),
   performs: exports_external.array(exports_external.string()).optional(),
   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
 });
@@ -11443,33 +11445,33 @@ var dataAtomsSchema = exports_external.object({
   comparisons: exports_external.array(comparisonAtomSchema).optional(),
   boundaries: exports_external.array(boundaryAtomSchema).optional(),
   claims: exports_external.array(claimAtomSchema).optional()
-}).superRefine((atoms2, ctx) => {
+}).superRefine((atoms, ctx) => {
   const stateValues = new Set;
   const stateNames = new Set;
-  for (const state of atoms2.states ?? []) {
+  for (const state of atoms.states ?? []) {
     stateNames.add(state.name);
     for (const value of state.values) {
       stateValues.add(value);
     }
   }
   const behaviorNames = new Set;
-  for (const behavior of atoms2.behaviors ?? []) {
+  for (const behavior of atoms.behaviors ?? []) {
     behaviorNames.add(behavior.name);
   }
   const roleNames = new Set;
-  for (const role of atoms2.roles ?? []) {
+  for (const role of atoms.roles ?? []) {
     roleNames.add(role.name);
   }
   const eventNames = new Set;
-  for (const event of atoms2.events ?? []) {
+  for (const event of atoms.events ?? []) {
     eventNames.add(event.name);
   }
   const metricNames = new Set;
-  for (const metric of atoms2.metrics ?? []) {
+  for (const metric of atoms.metrics ?? []) {
     metricNames.add(metric.name);
   }
-  if (atoms2.transitions && atoms2.transitions.length > 0) {
-    for (const transition of atoms2.transitions) {
+  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,
@@ -11499,8 +11501,8 @@ var dataAtomsSchema = exports_external.object({
       }
     }
   }
-  if (atoms2.roles && atoms2.roles.length > 0) {
-    for (const [index, role] of atoms2.roles.entries()) {
+  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({
@@ -11512,8 +11514,8 @@ var dataAtomsSchema = exports_external.object({
       }
     }
   }
-  if (atoms2.behaviors && atoms2.behaviors.length > 0) {
-    for (const [index, behavior] of atoms2.behaviors.entries()) {
+  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({
@@ -11525,9 +11527,9 @@ var dataAtomsSchema = exports_external.object({
       }
     }
   }
-  if (atoms2.rules && atoms2.rules.length > 0) {
+  if (atoms.rules && atoms.rules.length > 0) {
     const allowedDependsOn = new Set([...stateNames, ...metricNames]);
-    for (const [index, rule] of atoms2.rules.entries()) {
+    for (const [index, rule] of atoms.rules.entries()) {
       for (const dependency of rule.depends_on ?? []) {
         if (!allowedDependsOn.has(dependency)) {
           ctx.addIssue({
@@ -11539,8 +11541,8 @@ var dataAtomsSchema = exports_external.object({
       }
     }
   }
-  if (atoms2.events && atoms2.events.length > 0) {
-    for (const [index, event] of atoms2.events.entries()) {
+  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({
@@ -11597,10 +11599,10 @@ var atomsWhitelistByEntityType = {
   ["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;
     }
@@ -11610,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(),
@@ -11853,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
@@ -11865,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;
@@ -11944,32 +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) {
@@ -11978,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";
@@ -11992,6 +12203,10 @@ 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,
@@ -12003,6 +12218,7 @@ export {
   sorEntitySchema,
   sessionDecisionSchema,
   serializeYaml,
+  sectionSchema,
   scopeSchema,
   ruleAtomSchema,
   roleAtomSchema,
@@ -12015,6 +12231,7 @@ export {
   perspectiveSchema,
   parseYaml,
   parseRef,
+  paragraphAtomSchema,
   modelingSessionDataSchema,
   metricMilestoneSchema,
   metricAtomSchema,
@@ -12036,10 +12253,15 @@ export {
   entitySchema,
   entityRefPointerSchema,
   entityAtomSchema,
+  embeddingEntrySchema,
   documentSchema,
   documentModelingEntitySchema,
   documentEntitySchema,
   documentAdrEntitySchema,
+  docDigestSchema,
+  docChunkResultSchema,
+  docChunkParagraphSchema,
+  defaultRegistry,
   decisionPhaseSchema,
   decisionAtomSchema,
   dataAtomsSchema,
@@ -12064,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,
@@ -12073,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,
@@ -12083,14 +12312,12 @@ export {
   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,

package/package.json

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