@c4a/context 0.6.0-beta.4 → 0.6.0-beta.6

package/index.js

@@ -7016,6 +7016,23 @@ var assertDocumentEvidenceSectionMetadata = (section, options, field = "document
   assertHasSourceRefs(section, field);
 };
 // src/phases.ts
+var NO_ENTRY_DETECTED = "NO_ENTRY_DETECTED";
+
+class ExtractTsConfigurationError extends TypeError {
+  code = NO_ENTRY_DETECTED;
+  constructor(message) {
+    super(message);
+    this.name = "ExtractTsConfigurationError";
+  }
+}
+function normalizeExtractEntry(value) {
+  const slashPath = value.trim().replace(/\\/gu, "/");
+  const segments = slashPath.replace(/^\.\//u, "").split("/");
+  if (slashPath.length === 0 || slashPath.startsWith("/") || /^[A-Za-z]:\//u.test(slashPath) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    throw new TypeError(`extractTs entries must be source-relative file paths: ${value}`);
+  }
+  return segments.join("/");
+}
 var getSourceType = (sourceDefinition) => {
   if (sourceDefinition.kind === "source.collection" || sourceDefinition.kind === "source.ref") {
     if (!("type" in sourceDefinition)) {
@@ -7197,6 +7214,14 @@ var extractTs = (definition) => {
     throw new TypeError(`extractTs collection must be codegraph: ${definition.collection}`);
   }
   const sourceId = sourceDefinition.kind === "source.collection" ? sourceDefinition.type : sourceDefinition.name;
+  const mode = definition.mode ?? "exports";
+  if (mode === "scan" && definition.entries !== undefined) {
+    throw new TypeError("extractTs entries cannot be combined with mode: scan; scan mode uses every file matched by include");
+  }
+  if (definition.entries !== undefined && definition.entries.length === 0) {
+    throw new ExtractTsConfigurationError("extractTs entries must contain at least one source-relative file path");
+  }
+  const entries = definition.entries === undefined ? undefined : [...new Set(definition.entries.map(normalizeExtractEntry))];
   const phase = {
     kind: "phase.extract.ts",
     id: `extract:${sourceId}:${definition.collection}`,
@@ -7213,7 +7238,9 @@ var extractTs = (definition) => {
     source: sourceDefinition,
     collection: definition.collection,
     include: definition.include ?? ["src/**/*.{ts,tsx}"],
-    exportedOnly: definition.exportedOnly ?? true,
+    mode,
+    ...entries !== undefined ? { entries } : {},
+    exportedOnly: definition.exportedOnly ?? mode === "exports",
     out: {
       kind: "codegraph-entities",
       candidateFile: "unapproved/entities.jsonl",
@@ -11332,12 +11359,24 @@ var DEFAULT_FILE_SOURCES_REGISTRY_PATH = "sources/file/index.yaml";
 var DEFAULT_LARK_SOURCES_REGISTRY_PATH = "sources/lark/index.yaml";
 var SOURCE_TYPES = ["repo", "file", "lark"];
 var SOURCE_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/u;
+var REPO_DATE_NAMESPACE_PATTERN = /^\d{8}$/u;
 function assertSourceType(value, field) {
   if (!SOURCE_TYPES.includes(value)) {
     throw new TypeError(`${field} must be one of ${SOURCE_TYPES.join(", ")}: ${value}`);
   }
 }
-function source(name, options) {
+function source(name, options, moduleOptions) {
+  if (typeof options === "string") {
+    const moduleName = options;
+    const type2 = moduleOptions?.type ?? "repo";
+    assertSourceType(type2, "source type");
+    return {
+      kind: "source.ref",
+      type: type2,
+      name: `${name}/${moduleName}`,
+      materializedAt: type2 === "repo" ? `sources/repo/${name}/${moduleName}` : `sources/${type2}/${name}`
+    };
+  }
   const type = options?.type;
   if (type === undefined) {
     return {
@@ -11354,7 +11393,7 @@ function source(name, options) {
     materializedAt: `sources/${type}/${name}`
   };
 }
-var repoSourceRegistryEntrySchema = exports_external.object({
+var repoSourceModuleSchema = exports_external.object({
   id: exports_external.string().min(1).optional(),
   name: exports_external.string().min(1),
   local: exports_external.string().min(1).optional(),
@@ -11365,6 +11404,10 @@ var repoSourceRegistryEntrySchema = exports_external.object({
     ref: exports_external.string().min(1)
   }).strict().optional()
 }).strict();
+var repoSourceRegistryEntrySchema = exports_external.object({
+  name: exports_external.string().min(1),
+  modules: exports_external.array(repoSourceModuleSchema).min(1)
+}).strict();
 var sourceSnapshotSchema = exports_external.object({
   manifest: exports_external.string().min(1)
 }).strict();
@@ -11376,6 +11419,10 @@ var fileSourceRegistryEntrySchema = exports_external.object({
   materializedAt: exports_external.string().min(1).optional(),
   snapshot: sourceSnapshotSchema.optional()
 }).strict();
+var fileSourceBatchSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  modules: exports_external.array(fileSourceRegistryEntrySchema).min(1)
+}).strict();
 var larkSourceRegistryEntrySchema = exports_external.object({
   id: exports_external.string().min(1).optional(),
   name: exports_external.string().min(1),
@@ -11386,14 +11433,18 @@ var larkSourceRegistryEntrySchema = exports_external.object({
   title: exports_external.string().min(1).optional(),
   snapshot: sourceSnapshotSchema.optional()
 }).strict();
+var larkSourceBatchSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  modules: exports_external.array(larkSourceRegistryEntrySchema).min(1)
+}).strict();
 var repoSourcesRegistrySchema = exports_external.object({
   sources: exports_external.array(repoSourceRegistryEntrySchema).default([])
 }).strict();
 var fileSourcesRegistrySchema = exports_external.object({
-  sources: exports_external.array(fileSourceRegistryEntrySchema).default([])
+  sources: exports_external.array(exports_external.union([fileSourceRegistryEntrySchema, fileSourceBatchSchema])).default([])
 }).strict();
 var larkSourcesRegistrySchema = exports_external.object({
-  sources: exports_external.array(larkSourceRegistryEntrySchema).default([])
+  sources: exports_external.array(exports_external.union([larkSourceRegistryEntrySchema, larkSourceBatchSchema])).default([])
 }).strict();
 var formatRegistryIssues = (issues) => issues.map((issue) => {
   const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
@@ -11405,6 +11456,20 @@ var assertSourceName = (sourceType, name, registryPath) => {
     throw new TypeError(`${sourceType} source name must be a lowercase path-safe slug in ${registryPath}: ${name}`);
   }
 };
+var assertDateSourceNamespace = (sourceType, name, registryPath) => {
+  if (!REPO_DATE_NAMESPACE_PATTERN.test(name)) {
+    throw new TypeError(`${sourceType} source batch must be a valid YYYYMMDD date in ${registryPath}: ${name}`);
+  }
+  const year = Number(name.slice(0, 4));
+  const month = Number(name.slice(4, 6));
+  const day = Number(name.slice(6, 8));
+  const date = new Date(0);
+  date.setUTCHours(0, 0, 0, 0);
+  date.setUTCFullYear(year, month - 1, day);
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+    throw new TypeError(`${sourceType} source batch must be a valid YYYYMMDD date in ${registryPath}: ${name}`);
+  }
+};
 var assertRegistryRelativePath = (sourceType, name, field, value, registryPath) => {
   if (value.length === 0 || value.includes("\x00") || isAbsoluteRegistryPath(value)) {
     throw new TypeError(`${sourceType} source "${name}" in ${registryPath} has invalid ${field}; use a committed relative path`);
@@ -11424,7 +11489,9 @@ var assertWorkspaceRelativePath = (sourceType, name, field, value, registryPath)
 var assertDocumentSourcePath = (sourceType, name, field, value, registryPath, options = {}) => {
   assertWorkspaceRelativePath(sourceType, name, field, value, registryPath);
   const normalized = value.replaceAll("\\", "/");
-  const base = `sources/${sourceType}/${name}`;
+  const [namespace, module, ...rest] = name.split("/");
+  const batchName = module !== undefined && rest.length === 0 && REPO_DATE_NAMESPACE_PATTERN.test(namespace ?? "") ? namespace : name;
+  const base = `sources/${sourceType}/${batchName}`;
   if (normalized === base && options.allowBase === true)
     return;
   if (!normalized.startsWith(`${base}/`)) {
@@ -11440,40 +11507,55 @@ var parseRepoSourcesRegistry = (input, registryPath, absolutePath) => {
     throw new TypeError(`Invalid repo sources registry ${registryPath}: ${formatRegistryIssues(parsed.error.issues)}`);
   }
   const seenSourceKeys = new Set;
-  const repos = parsed.data.sources.map((entry) => {
-    assertSourceName("repo", entry.name, registryPath);
-    const id = entry.id ?? entry.name;
-    for (const key of new Set([entry.name, id])) {
-      if (seenSourceKeys.has(key)) {
-        throw new TypeError(`Duplicate repo source identifier "${key}" in ${registryPath}`);
-      }
-      seenSourceKeys.add(key);
-    }
-    const remote = entry.git?.remote;
-    const ref = entry.git?.ref;
-    if (!remote) {
-      throw new TypeError(`Repo source "${entry.name}" in ${registryPath} is missing remote`);
-    }
-    if (!ref) {
-      throw new TypeError(`Repo source "${entry.name}" in ${registryPath} is missing ref`);
-    }
-    const materializedAt = entry.materializedAt ?? `sources/repo/${entry.name}`;
-    assertWorkspaceRelativePath("repo", entry.name, "materializedAt", materializedAt, registryPath);
-    const normalized = {
-      id,
-      name: entry.name,
-      materializedAt,
-      remote,
-      ref
-    };
-    if (entry.local) {
-      normalized.local = entry.local;
-    }
-    if (entry.subpath) {
-      assertWorkspaceRelativePath("repo", entry.name, "subpath", entry.subpath, registryPath);
-      normalized.subpath = entry.subpath;
-    }
-    return normalized;
+  const moduleNamespaces = new Map;
+  const repos = parsed.data.sources.flatMap((namespaceEntry) => {
+    assertDateSourceNamespace("repo", namespaceEntry.name, registryPath);
+    const namespace = namespaceEntry.name;
+    return namespaceEntry.modules.map((entry) => {
+      assertSourceName("repo", entry.name, registryPath);
+      if (entry.id !== undefined)
+        assertSourceName("repo", entry.id, registryPath);
+      const existingNamespace = moduleNamespaces.get(entry.name);
+      if (existingNamespace !== undefined && existingNamespace !== namespace) {
+        throw new TypeError(`Duplicate repo module ${JSON.stringify(entry.name)} across date batches ${existingNamespace} and ${namespace} in ${registryPath}; repo module names are project-wide codegraph identities`);
+      }
+      moduleNamespaces.set(entry.name, namespace);
+      const name = `${namespace}/${entry.name}`;
+      const id = `${namespace}/${entry.id ?? entry.name}`;
+      for (const key of new Set([name, id])) {
+        if (seenSourceKeys.has(key)) {
+          throw new TypeError(`Duplicate repo source identifier "${key}" in ${registryPath}`);
+        }
+        seenSourceKeys.add(key);
+      }
+      const remote = entry.git?.remote;
+      const ref = entry.git?.ref;
+      if (!remote) {
+        throw new TypeError(`Repo source "${name}" in ${registryPath} is missing remote`);
+      }
+      if (!ref) {
+        throw new TypeError(`Repo source "${name}" in ${registryPath} is missing ref`);
+      }
+      const materializedAt = entry.materializedAt ?? `sources/repo/${namespace}/${entry.name}`;
+      assertWorkspaceRelativePath("repo", name, "materializedAt", materializedAt, registryPath);
+      const normalized = {
+        id,
+        name,
+        namespace,
+        module: entry.name,
+        materializedAt,
+        remote,
+        ref
+      };
+      if (entry.local) {
+        normalized.local = entry.local;
+      }
+      if (entry.subpath) {
+        assertWorkspaceRelativePath("repo", name, "subpath", entry.subpath, registryPath);
+        normalized.subpath = entry.subpath;
+      }
+      return normalized;
+    });
   });
   return {
     kind: "sources.registry.repo",
@@ -11488,34 +11570,43 @@ var parseFileSourcesRegistry = (input, registryPath) => {
     throw new TypeError(`Invalid file sources registry ${registryPath}: ${formatRegistryIssues(parsed.error.issues)}`);
   }
   const seenSourceKeys = new Set;
-  return parsed.data.sources.map((entry) => {
-    assertSourceName("file", entry.name, registryPath);
-    if (entry.local !== undefined) {
-      assertRegistryRelativePath("file", entry.name, "local", entry.local, registryPath);
-    }
-    const materializedAt = entry.materializedAt ?? `sources/file/${entry.name}`;
-    assertDocumentSourcePath("file", entry.name, "materializedAt", materializedAt, registryPath, { allowBase: true });
-    for (const [index, include] of (entry.include ?? []).entries()) {
-      assertDocumentIncludePath("file", entry.name, `include[${index}]`, include, registryPath);
-    }
-    if (entry.snapshot !== undefined) {
-      assertDocumentSourcePath("file", entry.name, "snapshot.manifest", entry.snapshot.manifest, registryPath);
-    }
-    const id = entry.id ?? entry.name;
-    for (const key of new Set([entry.name, id])) {
-      if (seenSourceKeys.has(key)) {
-        throw new TypeError(`Duplicate file source identifier "${key}" in ${registryPath}`);
+  return parsed.data.sources.flatMap((sourceEntry) => {
+    const namespace = "modules" in sourceEntry ? sourceEntry.name : undefined;
+    if (namespace !== undefined)
+      assertDateSourceNamespace("file", namespace, registryPath);
+    const entries = "modules" in sourceEntry ? sourceEntry.modules : [sourceEntry];
+    return entries.map((entry) => {
+      assertSourceName("file", entry.name, registryPath);
+      const name = namespace === undefined ? entry.name : `${namespace}/${entry.name}`;
+      if (entry.local !== undefined) {
+        assertRegistryRelativePath("file", name, "local", entry.local, registryPath);
+      }
+      const materializedAt = entry.materializedAt ?? `sources/file/${namespace ?? name}`;
+      assertDocumentSourcePath("file", name, "materializedAt", materializedAt, registryPath, { allowBase: true });
+      for (const [index, include] of (entry.include ?? []).entries()) {
+        assertDocumentIncludePath("file", name, `include[${index}]`, include, registryPath);
+      }
+      const snapshot = entry.snapshot ?? (namespace !== undefined ? { manifest: `sources/file/${namespace}/manifest.json` } : undefined);
+      if (snapshot !== undefined) {
+        assertDocumentSourcePath("file", name, "snapshot.manifest", snapshot.manifest, registryPath);
+      }
+      const id = namespace === undefined ? entry.id ?? entry.name : `${namespace}/${entry.id ?? entry.name}`;
+      for (const key of new Set([name, id])) {
+        if (seenSourceKeys.has(key)) {
+          throw new TypeError(`Duplicate file source identifier "${key}" in ${registryPath}`);
+        }
+        seenSourceKeys.add(key);
       }
-      seenSourceKeys.add(key);
-    }
-    return {
-      id,
-      name: entry.name,
-      materializedAt,
-      ...entry.local !== undefined ? { local: entry.local } : {},
-      ...entry.include !== undefined ? { include: entry.include } : {},
-      ...entry.snapshot !== undefined ? { snapshot: entry.snapshot } : {}
-    };
+      return {
+        id,
+        name,
+        ...namespace !== undefined ? { namespace, module: entry.name } : {},
+        materializedAt,
+        ...entry.local !== undefined ? { local: entry.local } : {},
+        ...entry.include !== undefined ? { include: entry.include } : {},
+        ...snapshot !== undefined ? { snapshot } : {}
+      };
+    });
   });
 };
 var parseLarkSourcesRegistry = (input, registryPath) => {
@@ -11524,38 +11615,47 @@ var parseLarkSourcesRegistry = (input, registryPath) => {
     throw new TypeError(`Invalid lark sources registry ${registryPath}: ${formatRegistryIssues(parsed.error.issues)}`);
   }
   const seenSourceKeys = new Set;
-  return parsed.data.sources.map((entry) => {
-    assertSourceName("lark", entry.name, registryPath);
-    const identityCount = [
-      entry.url !== undefined,
-      entry.docToken !== undefined,
-      entry.wikiToken !== undefined
-    ].filter(Boolean).length;
-    if (identityCount !== 1) {
-      throw new TypeError(`Lark source "${entry.name}" in ${registryPath} must declare exactly one of url, docToken, or wikiToken`);
-    }
-    const materializedAt = entry.materializedAt ?? `sources/lark/${entry.name}`;
-    assertDocumentSourcePath("lark", entry.name, "materializedAt", materializedAt, registryPath, { allowBase: true });
-    if (entry.snapshot !== undefined) {
-      assertDocumentSourcePath("lark", entry.name, "snapshot.manifest", entry.snapshot.manifest, registryPath);
-    }
-    const id = entry.id ?? entry.name;
-    for (const key of new Set([entry.name, id])) {
-      if (seenSourceKeys.has(key)) {
-        throw new TypeError(`Duplicate lark source identifier "${key}" in ${registryPath}`);
-      }
-      seenSourceKeys.add(key);
-    }
-    return {
-      id,
-      name: entry.name,
-      materializedAt,
-      ...entry.url !== undefined ? { url: entry.url } : {},
-      ...entry.docToken !== undefined ? { docToken: entry.docToken } : {},
-      ...entry.wikiToken !== undefined ? { wikiToken: entry.wikiToken } : {},
-      ...entry.title !== undefined ? { title: entry.title } : {},
-      ...entry.snapshot !== undefined ? { snapshot: entry.snapshot } : {}
-    };
+  return parsed.data.sources.flatMap((sourceEntry) => {
+    const namespace = "modules" in sourceEntry ? sourceEntry.name : undefined;
+    if (namespace !== undefined)
+      assertDateSourceNamespace("lark", namespace, registryPath);
+    const entries = "modules" in sourceEntry ? sourceEntry.modules : [sourceEntry];
+    return entries.map((entry) => {
+      assertSourceName("lark", entry.name, registryPath);
+      const name = namespace === undefined ? entry.name : `${namespace}/${entry.name}`;
+      const identityCount = [
+        entry.url !== undefined,
+        entry.docToken !== undefined,
+        entry.wikiToken !== undefined
+      ].filter(Boolean).length;
+      if (identityCount !== 1) {
+        throw new TypeError(`Lark source "${name}" in ${registryPath} must declare exactly one of url, docToken, or wikiToken`);
+      }
+      const materializedAt = entry.materializedAt ?? `sources/lark/${namespace ?? name}`;
+      assertDocumentSourcePath("lark", name, "materializedAt", materializedAt, registryPath, { allowBase: true });
+      const snapshot = entry.snapshot ?? (namespace !== undefined ? { manifest: `sources/lark/${namespace}/manifest.json` } : undefined);
+      if (snapshot !== undefined) {
+        assertDocumentSourcePath("lark", name, "snapshot.manifest", snapshot.manifest, registryPath);
+      }
+      const id = namespace === undefined ? entry.id ?? entry.name : `${namespace}/${entry.id ?? entry.name}`;
+      for (const key of new Set([name, id])) {
+        if (seenSourceKeys.has(key)) {
+          throw new TypeError(`Duplicate lark source identifier "${key}" in ${registryPath}`);
+        }
+        seenSourceKeys.add(key);
+      }
+      return {
+        id,
+        name,
+        ...namespace !== undefined ? { namespace, module: entry.name } : {},
+        materializedAt,
+        ...entry.url !== undefined ? { url: entry.url } : {},
+        ...entry.docToken !== undefined ? { docToken: entry.docToken } : {},
+        ...entry.wikiToken !== undefined ? { wikiToken: entry.wikiToken } : {},
+        ...entry.title !== undefined ? { title: entry.title } : {},
+        ...snapshot !== undefined ? { snapshot } : {}
+      };
+    });
   });
 };
 var readYamlIfPresent = async (absolutePath, emptyValue) => {
@@ -11632,6 +11732,8 @@ var resolveSourceReference = (reference, registry) => {
     kind: "source.repo",
     id: entry.id,
     name: entry.name,
+    namespace: entry.namespace,
+    module: entry.module,
     materializedAt: entry.materializedAt,
     git: {
       remote: entry.remote,
@@ -11656,10 +11758,23 @@ var allSources = (type) => {
 };
 
 // src/index.ts
-var defineProject = (project) => ({
-  kind: "context.project",
-  project
-});
+function assertUniquePhaseIds(phases) {
+  const firstById = new Map;
+  for (const [index, phase] of phases.entries()) {
+    const first = firstById.get(phase.id);
+    if (first !== undefined) {
+      throw new TypeError(`Duplicate Context phase id ${JSON.stringify(phase.id)}: phases[${first.index}] (${first.kind}) conflicts with phases[${index}] (${phase.kind}). Every phase id must be unique.`);
+    }
+    firstById.set(phase.id, { index, kind: phase.kind });
+  }
+}
+var defineProject = (project) => {
+  assertUniquePhaseIds(project.phases);
+  return {
+    kind: "context.project",
+    project
+  };
+};
 var normalizeTemplate = (template, builtInVars) => {
   const assertTemplatePath = (templatePath) => {
     if (!isSafeProjectRelativePath(templatePath)) {
@@ -11797,8 +11912,10 @@ export {
   alignProse,
   TOP_LEVEL_NAMESPACES,
   OKF_ROOTS,
+  NO_ENTRY_DETECTED,
   MAINLINE_COLLECTIONS,
   KNOWLEDGE_COLLECTIONS,
+  ExtractTsConfigurationError,
   DOC_MAINLINE_COLLECTIONS,
   DOCUMENT_STRUCTURE_SCHEMA_VERSION,
   DOCUMENT_SECTION_CONTENT_MODES,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/context",
-  "version": "0.6.0-beta.4",
+  "version": "0.6.0-beta.6",
   "type": "module",
   "dependencies": {
     "yaml": "^2.5.1",

package/phases.d.ts

@@ -60,6 +60,8 @@ export type ExtractTsPhaseDefinition = {
     source: RepoProjectSourceDefinition;
     collection: "codegraph";
     include: readonly string[];
+    mode: "exports" | "scan";
+    entries?: readonly string[];
     exportedOnly: boolean;
     transform?: MarkdownTransform | readonly MarkdownTransform[];
     out: {
@@ -69,6 +71,11 @@ export type ExtractTsPhaseDefinition = {
         initialStatus: "draft";
     };
 };
+export declare const NO_ENTRY_DETECTED: "NO_ENTRY_DETECTED";
+export declare class ExtractTsConfigurationError extends TypeError {
+    readonly code: "NO_ENTRY_DETECTED";
+    constructor(message: string);
+}
 export type CaptureFilePhaseDefinition = {
     kind: "phase.capture.file";
     id: string;
@@ -153,6 +160,8 @@ export declare const extractTs: (definition: {
     source: RepoProjectSourceDefinition;
     collection: "codegraph";
     include?: readonly string[];
+    mode?: "exports" | "scan";
+    entries?: readonly string[];
     exportedOnly?: boolean;
     transform?: MarkdownTransform | readonly MarkdownTransform[];
 }) => ExtractTsPhaseDefinition;

package/sources.d.ts

@@ -7,6 +7,8 @@ export type RepoSourceDefinition = {
     kind: "source.repo";
     id: string;
     name: string;
+    namespace: string;
+    module: string;
     local?: string;
     subpath?: string;
     materializedAt: string;
@@ -19,6 +21,8 @@ export type FileSourceDefinition = {
     kind: "source.file";
     id: string;
     name: string;
+    namespace?: string;
+    module?: string;
     local?: string;
     materializedAt: string;
     include?: readonly string[];
@@ -30,6 +34,8 @@ export type LarkSourceDefinition = {
     kind: "source.lark";
     id: string;
     name: string;
+    namespace?: string;
+    module?: string;
     materializedAt: string;
     url?: string;
     docToken?: string;
@@ -62,6 +68,8 @@ export type SourceCollectionReference<TType extends SourceType = SourceType> = {
 export type RepoSourceRegistryEntry = {
     id: string;
     name: string;
+    namespace: string;
+    module: string;
     local?: string;
     subpath?: string;
     materializedAt: string;
@@ -71,6 +79,8 @@ export type RepoSourceRegistryEntry = {
 export type FileSourceRegistryEntry = {
     id: string;
     name: string;
+    namespace?: string;
+    module?: string;
     local?: string;
     materializedAt: string;
     include?: readonly string[];
@@ -81,6 +91,8 @@ export type FileSourceRegistryEntry = {
 export type LarkSourceRegistryEntry = {
     id: string;
     name: string;
+    namespace?: string;
+    module?: string;
     materializedAt: string;
     url?: string;
     docToken?: string;
@@ -124,6 +136,16 @@ export type DocumentSourceDefinition = FileSourceDefinition | LarkSourceDefiniti
 export type RepoProjectSourceDefinition = RepoSourceDefinition | RepoSourceReference | SourceCollectionReference<"repo">;
 export type ProjectSourceDefinition = SourceDefinition | SourceCollectionReference;
 export declare function source(name: string): RegistrySourceReference;
+export declare function source(namespace: string, module: string): RepoSourceReference;
+export declare function source(namespace: string, module: string, options: {
+    type: "repo";
+}): RepoSourceReference;
+export declare function source(namespace: string, module: string, options: {
+    type: "file";
+}): FileSourceReference;
+export declare function source(namespace: string, module: string, options: {
+    type: "lark";
+}): LarkSourceReference;
 export declare function source(name: string, options: {
     type: "repo";
 }): RepoSourceReference;