@agentproto/corpus 0.1.0-alpha.3 → 0.1.0-alpha.4

package/dist/index.mjs

@@ -1,9 +1,9 @@
 export { systemClock } from './chunk-KYX2DTEH.mjs';
-import { REFINED_KIND_SCHEMA, resolveKnowledge } from './chunk-3P23OX5X.mjs';
-export { REFINED_KIND_SCHEMA, isRefinedKind, resolveKnowledge } from './chunk-3P23OX5X.mjs';
+import { REFINED_KIND_SCHEMA, resolveKnowledge } from './chunk-JV6VRZ6U.mjs';
+export { REFINED_KIND_SCHEMA, isRefinedKind, resolveKnowledge } from './chunk-JV6VRZ6U.mjs';
 import { CandidatesSidecar } from './chunk-UPX26MYH.mjs';
 export { CandidatesSidecar, SidecarDuplicateError, SidecarNotFoundError } from './chunk-UPX26MYH.mjs';
-import matter from 'gray-matter';
+import matter6 from 'gray-matter';
 import { createHash } from 'crypto';
 import { z } from 'zod';
 import { parse, stringify } from 'yaml';
@@ -379,7 +379,7 @@ var CorpusWorkspaceReader = class {
     };
     for (const path of mdFiles) {
       const content = await this.opts.fs.readFile(path);
-      const parsed = matter(content);
+      const parsed = matter6(content);
       const file = {
         // Workspace-relative path. The walk returns paths anchored at
         // the host's storage root (which already includes `root` for
@@ -535,7 +535,7 @@ var CorpusWorkspaceWriter = class _CorpusWorkspaceWriter {
   }
 };
 function serializeMarkdown(doc) {
-  return matter.stringify(doc.body.startsWith("\n") ? doc.body : "\n" + doc.body, doc.frontmatter);
+  return matter6.stringify(doc.body.startsWith("\n") ? doc.body : "\n" + doc.body, doc.frontmatter);
 }
 
 // src/importers/runner.ts
@@ -673,7 +673,7 @@ function serializeSource(source, archiveDirSegment, clock) {
       }
     };
   }
-  return matter.stringify(
+  return matter6.stringify(
     source.body.startsWith("\n") ? source.body : "\n" + source.body,
     fm
   );
@@ -995,7 +995,9 @@ var DistillRunner = class {
     const items = await this.opts.distiller.distill({
       title: source.title,
       body: source.body,
-      ...source.tags ? { tags: source.tags } : {}
+      ...source.tags ? { tags: source.tags } : {},
+      ...source.kinds ? { kinds: source.kinds } : {},
+      ...source.instruction ? { instruction: source.instruction } : {}
     });
     const year = this.opts.clock.now().getUTCFullYear();
     const flat = this.opts.layout === "flat";
@@ -1028,7 +1030,7 @@ function serializeEntry(item, slug, source, clock) {
     sources: [source.id],
     // ← derivedFrom / provenance edge
     confidence: typeof item.confidence === "number" ? item.confidence : 0.7,
-    tags: dedupeTags(item.tags, source.tags),
+    tags: withAspect(dedupeTags(item.tags, source.tags), source.aspect),
     metadata: {
       corpus: {
         status: "active",
@@ -1042,7 +1044,14 @@ function serializeEntry(item, slug, source, clock) {
     }
   };
   const body = item.body.trim();
-  return matter.stringify(body.startsWith("\n") ? body : "\n" + body, fm);
+  return matter6.stringify(body.startsWith("\n") ? body : "\n" + body, fm);
+}
+function withAspect(tags, aspect) {
+  if (!aspect) return [...tags];
+  const value = sanitizeTag(aspect);
+  if (!value) return [...tags];
+  const facet = `aspect:${value}`;
+  return tags.includes(facet) ? [...tags] : [facet, ...tags];
 }
 function dedupeTags(a, b) {
   const out = /* @__PURE__ */ new Set();
@@ -1064,10 +1073,16 @@ var DISTILLED_ITEM = z.object({
   tags: z.array(z.string()).optional()
 }).loose();
 function buildDistillPrompt(input, maxItems) {
-  return `You distill a raw source (a video transcript or article) into REFINED, reusable knowledge for an AI operator. Extract the durable insights \u2014 not a summary of the video, but the transferable lessons.
+  const lensBlock = input.instruction?.trim() ? `LENS \u2014 read the source THROUGH this aspect, extract ONLY what serves it:
+${input.instruction.trim()}
+
+` : "";
+  const kinds = input.kinds?.length ? input.kinds : ["principle", "pattern", "critique", "summary", "example"];
+  const kindUnion = kinds.map((k) => `"${k}"`).join(" | ");
+  return `${lensBlock}You distill a raw source (a video transcript or article) into REFINED, reusable knowledge for an AI operator. Extract the durable insights \u2014 not a summary of the video, but the transferable lessons.
 
 Return a JSON array (max ${maxItems} items). Each item:
-{ "kind": one of "principle" | "pattern" | "critique" | "summary" | "example",
+{ "kind": one of ${kindUnion},
   "title": short imperative/declarative title,
   "body": 2-5 sentences, SELF-CONTAINED (no "the speaker says"), the actual insight,
   "confidence": 0-1, "tags": [short topic tags] }
@@ -1125,7 +1140,7 @@ async function scanDistilledSourceIds(fs) {
     if (!rel.endsWith(".md")) continue;
     const path = rel.startsWith("entries/") ? rel : `entries/${rel}`;
     try {
-      const fm = ENTRY_SOURCES.parse(matter(await fs.readFile(path)).data);
+      const fm = ENTRY_SOURCES.parse(matter6(await fs.readFile(path)).data);
       if (fm.sources) for (const s of fm.sources) ids.add(s);
     } catch {
     }
@@ -1174,47 +1189,309 @@ function createDistillRegistry() {
   };
 }
 
-// src/distill/run.ts
-async function runDistill(descriptor, scope) {
+// src/distill/lens.ts
+function lensAspect(lens) {
+  return lens.aspect ?? lens.id;
+}
+function lensAspectTag(lens) {
+  return `aspect:${lensAspect(lens)}`;
+}
+
+// src/distill/generate.ts
+async function distillFromImporter(opts) {
   const report = {
-    descriptorId: descriptor.id,
-    scopeId: scope.id,
     unitsConsidered: 0,
     unitsDistilled: 0,
     entriesWritten: 0,
-    skipped: 0
+    skipped: 0,
+    unchanged: 0
   };
-  const target = await descriptor.target(scope);
-  const distilled = await scanDistilledSourceIds(target.fs);
-  const binding = descriptor.bind(scope, target);
-  const config = await binding.prepare(distilled);
-  if (!config) return report;
   const runner = new DistillRunner({
-    fs: target.fs,
-    clock: target.clock,
-    distiller: descriptor.distiller(scope)
+    fs: opts.fs,
+    clock: opts.clock,
+    distiller: opts.distiller,
+    ...opts.layout ? { layout: opts.layout } : {}
   });
-  for await (const imported of binding.importer.enumerate({
-    importerId: descriptor.id,
-    config
+  const provenanceId = opts.provenanceId ?? ((s) => s.slug);
+  const lensId = opts.lens?.id;
+  for await (const imported of opts.importer.enumerate({
+    importerId: opts.importerId,
+    config: opts.config
   })) {
     report.unitsConsidered++;
+    const sourceId = provenanceId(imported);
+    if (opts.index && await opts.index.isDistilled(sourceId, imported.contentHash, lensId)) {
+      report.unchanged++;
+      continue;
+    }
     const source = {
-      id: binding.provenanceId(imported),
+      id: sourceId,
       title: imported.title,
       body: imported.body,
-      ...imported.tags ? { tags: imported.tags } : {}
+      ...imported.tags ? { tags: imported.tags } : {},
+      ...opts.lens?.prompt ? { instruction: opts.lens.prompt } : {},
+      ...opts.lens?.kinds ? { kinds: opts.lens.kinds } : {},
+      ...opts.lens ? { aspect: lensAspect(opts.lens) } : {}
     };
     try {
       const r = await runner.run(source);
       if (r.entryPaths.length > 0) report.unitsDistilled++;
       report.entriesWritten += r.entryPaths.length;
       report.skipped += r.skipped.length;
+      if (opts.index) {
+        await opts.index.record({
+          sourceId,
+          ...lensId ? { lensId } : {},
+          title: imported.title,
+          distilledAt: opts.clock.now().toISOString(),
+          ...opts.engine ? { engine: opts.engine } : {},
+          ...imported.contentHash ? { contentHash: imported.contentHash } : {},
+          entryCount: r.entryPaths.length,
+          ...r.entryPaths.length ? { entryPaths: r.entryPaths } : {}
+        });
+      }
     } catch {
     }
   }
   return report;
 }
+
+// src/distill/run.ts
+async function runDistill(descriptor, scope, opts = {}) {
+  const empty = {
+    unitsConsidered: 0,
+    unitsDistilled: 0,
+    entriesWritten: 0,
+    skipped: 0,
+    unchanged: 0
+  };
+  const target = await descriptor.target(scope);
+  const distilled = await scanDistilledSourceIds(target.fs);
+  const binding = descriptor.bind(scope, target);
+  const config = await binding.prepare(distilled);
+  if (!config) {
+    return { descriptorId: descriptor.id, scopeId: scope.id, ...empty };
+  }
+  const core = await distillFromImporter({
+    fs: target.fs,
+    clock: target.clock,
+    distiller: descriptor.distiller(scope),
+    importer: binding.importer,
+    importerId: descriptor.id,
+    config,
+    provenanceId: binding.provenanceId,
+    ...opts.index ? { index: opts.index } : {},
+    ...opts.engine ? { engine: opts.engine } : {},
+    ...opts.lens ? { lens: opts.lens } : {}
+  });
+  return { descriptorId: descriptor.id, scopeId: scope.id, ...core };
+}
+var DISTILL_INDEX_PATH = "_distill-index.yaml";
+var DistillIndex = class {
+  fs;
+  path;
+  constructor(opts) {
+    this.fs = opts.fs;
+    this.path = opts.path ?? DISTILL_INDEX_PATH;
+  }
+  /** Every record on disk. Empty for a fresh corpus (no file yet). */
+  async load() {
+    if (!await this.fs.exists(this.path)) return [];
+    const content = await this.fs.readFile(this.path);
+    if (!content.trim()) return [];
+    const parsed = parse(content);
+    if (!parsed || !Array.isArray(parsed.runs)) return [];
+    return parsed.runs;
+  }
+  /**
+   * The record for a `(sourceId, lensId)` pair, or null if never distilled.
+   * `lensId` undefined matches the generic lens-less row (back-compat).
+   */
+  async get(sourceId, lensId) {
+    const rows = await this.load();
+    return rows.find((r) => r.sourceId === sourceId && r.lensId === lensId) ?? null;
+  }
+  /**
+   * True if the `(source, lens)` pair was distilled with a matching content
+   * hash (when given). Each lens has independent cadence over the same source.
+   */
+  async isDistilled(sourceId, contentHash, lensId) {
+    const row = await this.get(sourceId, lensId);
+    if (!row) return false;
+    if (contentHash === void 0) return true;
+    return row.contentHash === contentHash;
+  }
+  /**
+   * Upsert a record by `(sourceId, lensId)`. Re-distilling overwrites that
+   * pair's row (cadence is "latest run wins") while leaving the same source's
+   * other lens rows untouched; a new pair appends. Returns the full list.
+   */
+  async record(row) {
+    const existing = await this.load();
+    const idx = existing.findIndex(
+      (r) => r.sourceId === row.sourceId && r.lensId === row.lensId
+    );
+    const next = idx === -1 ? [...existing, row] : [...existing.slice(0, idx), row, ...existing.slice(idx + 1)];
+    await this.write(next);
+    return next;
+  }
+  /** Whole-file replace. Prefer {@link record} for normal flow. */
+  async write(runs) {
+    const shape = { runs };
+    await this.fs.writeFile(this.path, stringify(shape));
+  }
+};
+var SYNTHESIS_ROLE_TAG = "role:synthesis";
+var ATOM_FRONTMATTER = z.object({
+  schema: z.string().optional().catch(void 0),
+  slug: z.string().optional().catch(void 0),
+  title: z.string().optional().catch(void 0),
+  sources: z.array(z.string()).optional().catch(void 0),
+  confidence: z.number().optional().catch(void 0),
+  tags: z.array(z.string()).optional().catch(void 0),
+  supersedes: z.array(z.string()).optional().catch(void 0),
+  metadata: z.object({
+    corpus: z.object({ status: z.string().optional().catch(void 0) }).loose().optional().catch(void 0)
+  }).loose().optional().catch(void 0)
+}).loose();
+async function readEntries(fs) {
+  let rels;
+  try {
+    rels = await fs.walk("entries");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const rel of rels) {
+    if (!rel.endsWith(".md")) continue;
+    const path = `entries/${rel}`;
+    let parsed;
+    try {
+      parsed = matter6(await fs.readFile(path));
+    } catch {
+      continue;
+    }
+    const fm = ATOM_FRONTMATTER.parse(parsed.data);
+    if (fm.schema !== "knowledge.entry/v1") continue;
+    const tags = fm.tags ?? [];
+    out.push({
+      slug: fm.slug ?? path,
+      title: fm.title ?? "",
+      body: parsed.content.trim(),
+      confidence: fm.confidence ?? 0,
+      tags,
+      supersedes: fm.supersedes ?? [],
+      path,
+      archived: fm.metadata?.corpus?.status === "archived",
+      isSynthesis: tags.includes(SYNTHESIS_ROLE_TAG)
+    });
+  }
+  return out;
+}
+async function currentLensAtoms(fs, lens) {
+  const aspectTag = lensAspectTag(lens);
+  const entries = await readEntries(fs);
+  const superseded = /* @__PURE__ */ new Set();
+  for (const e of entries) for (const s of e.supersedes) superseded.add(s);
+  return entries.filter(
+    (e) => !e.archived && !e.isSynthesis && e.tags.includes(aspectTag) && !superseded.has(e.slug)
+  ).sort((a, b) => b.confidence - a.confidence).map((e) => ({ slug: e.slug, title: e.title, body: e.body }));
+}
+function defaultSynthesisPath(lens) {
+  return `entries/summaries/${lensAspect(lens)}-knowledge.md`;
+}
+async function lensSynthesisStale(fs, lens) {
+  const atoms = await currentLensAtoms(fs, lens);
+  const atomSlugs = new Set(atoms.map((a) => a.slug));
+  const path = lens.synthesisPath ?? defaultSynthesisPath(lens);
+  if (!await fs.exists(path)) {
+    return { stale: atoms.length > 0, reason: atoms.length > 0 ? "missing" : "fresh", atomCount: atoms.length };
+  }
+  let recorded = [];
+  try {
+    const fm = ATOM_FRONTMATTER.parse(matter6(await fs.readFile(path)).data);
+    recorded = fm.sources ?? [];
+  } catch {
+    return { stale: true, reason: "drifted", atomCount: atoms.length };
+  }
+  const recordedSet = new Set(recorded);
+  const same = recordedSet.size === atomSlugs.size && [...atomSlugs].every((s) => recordedSet.has(s));
+  return {
+    stale: !same,
+    reason: same ? "fresh" : "drifted",
+    atomCount: atoms.length
+  };
+}
+async function synthesizeLens(opts) {
+  const { fs, clock, synthesizer, lens } = opts;
+  const aspect = lensAspect(lens);
+  const entries = await readEntries(fs);
+  const aspectTag = lensAspectTag(lens);
+  const considered = entries.filter(
+    (e) => !e.archived && !e.isSynthesis && e.tags.includes(aspectTag)
+  ).length;
+  const atoms = await currentLensAtoms(fs, lens);
+  if (atoms.length === 0) {
+    return { lensId: lens.id, aspect, atomsConsidered: considered, atomsUsed: 0, wrote: false };
+  }
+  const body = await synthesizer.synthesize({ aspect, label: lens.label, atoms });
+  const path = lens.synthesisPath ?? defaultSynthesisPath(lens);
+  await fs.writeFile(path, serializeSynthesis(body, lens, atoms, clock));
+  return {
+    lensId: lens.id,
+    aspect,
+    atomsConsidered: considered,
+    atomsUsed: atoms.length,
+    wrote: true,
+    path
+  };
+}
+function serializeSynthesis(body, lens, atoms, clock) {
+  const now = clock.now().toISOString();
+  const slug = `${lensAspect(lens)}-knowledge`;
+  const fm = {
+    schema: "knowledge.entry/v1",
+    slug,
+    kind: "summary",
+    title: `${lens.label} \u2014 current view`,
+    updated_at: now,
+    // Provenance: the atoms this synthesis consolidates (derivedFrom edges).
+    sources: atoms.map((a) => a.slug),
+    confidence: 0.8,
+    // Faceted aspect tag + the synthesis role marker (kept verbatim — both are
+    // AIP-10 facet structure, not plain tags, so they bypass the topic sanitizer).
+    tags: [lensAspectTag(lens), SYNTHESIS_ROLE_TAG],
+    metadata: {
+      corpus: {
+        status: "active",
+        promotionMode: "lens-synthesis",
+        promotedAt: now,
+        lens: lens.id
+      }
+    }
+  };
+  const trimmed = body.trim();
+  return matter6.stringify(trimmed.startsWith("\n") ? trimmed : "\n" + trimmed, fm);
+}
+function buildSynthesisPrompt(input) {
+  const atomBlock = input.atoms.map((a, i) => `### Atom ${i + 1}: ${a.title}
+${a.body}`).join("\n\n");
+  return `You consolidate the CURRENT knowledge of one aspect into a single living document for an AI operator. You are given the current (non-superseded) atoms \u2014 each a durable insight already extracted. Earlier reversed decisions have already been removed, so treat every atom as currently true.
+
+ASPECT: ${input.aspect} (${input.label})
+
+Write a coherent, well-structured markdown document that:
+- Synthesizes the atoms into a unified current view \u2014 not a list, a narrative the operator can act on.
+- Resolves overlaps; group related atoms under headings.
+- States the CURRENT position plainly. Do not hedge with "previously" / "it was decided" \u2014 this is the present truth.
+- Stays grounded ONLY in the atoms; invent nothing.
+- Writes in ENGLISH.
+
+CURRENT ATOMS:
+${atomBlock}
+
+Return ONLY the markdown document body (no frontmatter, no code fence).`;
+}
 var ANTHROPIC_RESPONSE = z.object({
   content: z.array(
     z.object({ type: z.string(), text: z.string().optional() }).loose()
@@ -2523,6 +2800,20 @@ var CorpusIndexer = class {
     let removed = 0;
     let skipped = 0;
     let chunkCount = 0;
+    let sourcesPushed = 0;
+    if (this.opts.writer.pushSource) {
+      for (const source of snapshot.sources) {
+        const sourceId = source.frontmatter.id;
+        if (typeof sourceId !== "string") continue;
+        await this.opts.writer.pushSource({
+          sourceId,
+          sourcePath: source.path,
+          title: typeof source.frontmatter.title === "string" ? source.frontmatter.title : void 0,
+          sourceFrontmatter: source.frontmatter
+        });
+        sourcesPushed++;
+      }
+    }
     for (const entry of snapshot.entries) {
       const status = readStatus(entry);
       if (status === "active") {
@@ -2539,7 +2830,7 @@ var CorpusIndexer = class {
         skipped++;
       }
     }
-    return { pushed, removed, skipped, chunkCount };
+    return { pushed, removed, skipped, chunkCount, sourcesPushed };
   }
   /**
    * Re-sync a single entry by slug. The lifecycle's `promote`
@@ -2585,7 +2876,10 @@ var CorpusIndexer = class {
         confidence: entry.frontmatter.confidence,
         tags: entry.frontmatter.tags,
         ...corpus
-      }
+      },
+      // Full frontmatter for a graph-projection writer (relation arrays the
+      // flattened entryMetadata drops). Vector engines ignore it.
+      entryFrontmatter: entry.frontmatter
     });
     return chunks.length;
   }
@@ -3102,7 +3396,7 @@ var PlaybookLifecycle = class {
   async writeWith(playbook, patch) {
     const writer = new CorpusWorkspaceWriter({ fs: this.opts.fs });
     const nextFm = patch({ ...playbook.file.frontmatter });
-    const nextContent = matter.stringify(
+    const nextContent = matter6.stringify(
       playbook.body.startsWith("\n") ? playbook.body : "\n" + playbook.body,
       nextFm
     );
@@ -3270,7 +3564,7 @@ var PlaybookEvaluator = class {
         note: `n=${metrics.sampleSize} winRate=${metrics.winRateVsBaseline.toFixed(3)}`
       })
     );
-    const content = matter.stringify(
+    const content = matter6.stringify(
       playbook.body.startsWith("\n") ? playbook.body : "\n" + playbook.body,
       fm
     );
@@ -3309,6 +3603,6 @@ function joinPath5(a, b) {
 var SPEC_NAME = "agentcorpus/v1";
 var SPEC_VERSION = "0.1.0-alpha";
 
-export { ANY_REF, ClaudeDistiller, ConversationImporter, CorpusEventEmitter, CorpusIndexer, CorpusLinter, CorpusPromoter, CorpusValidator, CorpusVersionConflictError, CorpusWorkspaceReader, CorpusWorkspaceWriter, DEFAULT_TRANSITIONS, DistillRunner, EMPTY_SELECTOR, IllegalPlaybookTransitionError, IllegalTransitionError, ImporterRunner, KbMigrationImporter, LocalFilesImporter, MemFs, OperatorOverlayResolver, OverlayFs, PlaybookEvaluator, PlaybookLifecycle, PlaybookNotFoundError, PlaybookRegistry, PromoteRejectedError, ReadOnlyFs, ReviewerTrackRecord, SPEC_NAME, SPEC_VERSION, StackResolver, SyncRunner, WELL_KNOWN_AXES, WHITEOUT_SUFFIX, WebImporter, aggregateReviewerScores, appendAttestation, assertTransition, buildDistillPrompt, buildOverlayFromStack, canTransition, capabilityAxis, chunkText, compileLegacyPlaybookBinding, computeReviewerCalibration, createAxisRegistry, createDistillRegistry, enumerateWindowRefs, evaluateAccess, evaluateCapability, evaluateGate, extractAutoPromoteConfig, flattenPackRefs, identityAxis, isEmptySelector, isEntrySlug, isSourceSlug, makeAttestation, matchAttachmentRefs, matchAttachments, matchesLanguageFilter, matchesSelector, modelDistiller, normalizeLanguageTag, parseItems, parseSelectorFrontmatter, parseWindowRef, partitionStackRefs, pearsonCorrelation, positionAxis, prefixedRefNormalizer, readAccessModes, readAccessSpec, readAttestations, readEntryLanguage, readOperatorLocale, readWorkspaceDefaultLanguage, renderOverlays, resolveLanguageFilter, roleAxis, runDistill, scanDistilledSourceIds, slugify, transitionGraphFromCollection, uniqueSlug, windowRef, windowSlug };
+export { ANY_REF, ClaudeDistiller, ConversationImporter, CorpusEventEmitter, CorpusIndexer, CorpusLinter, CorpusPromoter, CorpusValidator, CorpusVersionConflictError, CorpusWorkspaceReader, CorpusWorkspaceWriter, DEFAULT_TRANSITIONS, DISTILL_INDEX_PATH, DistillIndex, DistillRunner, EMPTY_SELECTOR, IllegalPlaybookTransitionError, IllegalTransitionError, ImporterRunner, KbMigrationImporter, LocalFilesImporter, MemFs, OperatorOverlayResolver, OverlayFs, PlaybookEvaluator, PlaybookLifecycle, PlaybookNotFoundError, PlaybookRegistry, PromoteRejectedError, ReadOnlyFs, ReviewerTrackRecord, SPEC_NAME, SPEC_VERSION, SYNTHESIS_ROLE_TAG, StackResolver, SyncRunner, WELL_KNOWN_AXES, WHITEOUT_SUFFIX, WebImporter, aggregateReviewerScores, appendAttestation, assertTransition, buildDistillPrompt, buildOverlayFromStack, buildSynthesisPrompt, canTransition, capabilityAxis, chunkText, compileLegacyPlaybookBinding, computeReviewerCalibration, createAxisRegistry, createDistillRegistry, currentLensAtoms, defaultSynthesisPath, distillFromImporter, enumerateWindowRefs, evaluateAccess, evaluateCapability, evaluateGate, extractAutoPromoteConfig, flattenPackRefs, identityAxis, isEmptySelector, isEntrySlug, isSourceSlug, lensAspect, lensAspectTag, lensSynthesisStale, makeAttestation, matchAttachmentRefs, matchAttachments, matchesLanguageFilter, matchesSelector, modelDistiller, normalizeLanguageTag, parseItems, parseSelectorFrontmatter, parseWindowRef, partitionStackRefs, pearsonCorrelation, positionAxis, prefixedRefNormalizer, readAccessModes, readAccessSpec, readAttestations, readEntryLanguage, readOperatorLocale, readWorkspaceDefaultLanguage, renderOverlays, resolveLanguageFilter, roleAxis, runDistill, scanDistilledSourceIds, slugify, synthesizeLens, transitionGraphFromCollection, uniqueSlug, windowRef, windowSlug };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map