@c4a/core 0.6.19 → 0.7.0

package/index.js

@@ -12980,10 +12980,11 @@ var DEFAULT_PATH_FILTER = {
     ]
   },
   code: {
-    include: ["**/*.{ts,tsx}"],
+    include: ["**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"],
     exclude: [
       "**/__{tests,test,e2e,mocks,fixtures,snapshots}__/**",
-      "**/*.{test,spec,d}.{ts,tsx}"
+      "**/*.{test,spec}.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
+      "**/*.d.{ts,mts,cts}"
     ]
   },
   doc: {
@@ -13125,6 +13126,419 @@ var factSchema = exports_external.union([
   activeFactSchema,
   deprecatedFactSchema
 ]);
+// src/schemas/indexerEvidenceAdapterSchema.ts
+import { createHash } from "node:crypto";
+
+// src/indexerOutputRedaction.ts
+var INDEXER_OUTPUT_REDACTION_MARKER = "[REDACTED:indexer-output]";
+var SECRET_TOKEN = /^(?:password|passwd|pwd|secret|token|credential|credentials|cookie)$/u;
+var SECRET_COMPOUND = /^(?:api-key|access-key|private-key|client-secret|access-token|refresh-token)$/u;
+var NON_SECRET_SUFFIX = new Set([
+  "budget",
+  "count",
+  "digest",
+  "fingerprint",
+  "hash",
+  "index",
+  "kind",
+  "length",
+  "limit",
+  "name",
+  "ref",
+  "reference",
+  "references",
+  "refs",
+  "status",
+  "type"
+]);
+function keyTokens(key) {
+  return key.replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replace(/[^A-Za-z0-9]+/gu, "-").toLowerCase().split("-").filter(Boolean);
+}
+function sensitiveKey(key, value) {
+  const tokens = keyTokens(key);
+  if (tokens.length === 0)
+    return false;
+  const normalized = tokens.join("-");
+  if (normalized === "authorization" && value !== null && typeof value === "object") {
+    return false;
+  }
+  if (NON_SECRET_SUFFIX.has(tokens.at(-1)))
+    return false;
+  return SECRET_COMPOUND.test(normalized) || tokens.some((token) => SECRET_TOKEN.test(token)) || normalized === "authorization";
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function normalizedBlockedScalars(policy) {
+  const identities = new Set;
+  const values = [];
+  for (const value of policy.blocked_scalars ?? []) {
+    if (typeof value === "number" && !Number.isFinite(value))
+      continue;
+    if (typeof value === "string" && value.length === 0)
+      continue;
+    const identity = `${typeof value}:${String(value)}`;
+    if (identities.has(identity))
+      continue;
+    identities.add(identity);
+    values.push(value);
+  }
+  return values.sort((left, right) => String(right).length - String(left).length);
+}
+function replaceWithCount(value, pattern, replacement, count) {
+  return value.replace(pattern, (...args) => {
+    count.replacements += 1;
+    if (typeof replacement === "string")
+      return replacement;
+    return replacement(...args.slice(0, -2));
+  });
+}
+function redactKnownText(value, count) {
+  let output = value;
+  output = replaceWithCount(output, /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/gu, INDEXER_OUTPUT_REDACTION_MARKER, count);
+  output = replaceWithCount(output, /(\bauthorization\s*:\s*(?:bearer|basic)\s+)[^\s,;]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  output = replaceWithCount(output, /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}@`, count);
+  output = replaceWithCount(output, /([?&](?:access_token|refresh_token|api_key|password|secret)=)[^&#\s]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  const key = "(?:[A-Za-z0-9_.-]*(?:password|passwd|pwd|secret|token|credential|cookie)[A-Za-z0-9_.-]*|api[-_]?key|access[-_]?(?:key|token)|private[-_]?key|client[-_]?secret|authorization)";
+  const assignment = `(?:=\\s*|:\\s+(?=\\S)|:\\s*(?=["']))`;
+  output = replaceWithCount(output, new RegExp(`((?:["']?${key}["']?)\\s*${assignment})(?:"(?:\\\\.|[^"])*"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)`, "giu"), (_match, prefix) => `${prefix}"${INDEXER_OUTPUT_REDACTION_MARKER}"`, count);
+  return output;
+}
+function redactBlockedText(value, blocked, count) {
+  let output = value;
+  for (const scalar of blocked) {
+    const pattern = typeof scalar === "number" ? new RegExp(`(?<![0-9.])${escapeRegExp(String(scalar))}(?![0-9.])`, "gu") : new RegExp(escapeRegExp(scalar), "gu");
+    output = replaceWithCount(output, pattern, INDEXER_OUTPUT_REDACTION_MARKER, count);
+  }
+  return output;
+}
+function redactText(value, blocked, count) {
+  return redactBlockedText(redactKnownText(value, count), blocked, count);
+}
+function blockedScalar(value, blocked) {
+  return blocked.some((candidate) => typeof candidate === typeof value && Object.is(candidate, value));
+}
+function redactStructured(value, blocked, count, seen) {
+  if (blockedScalar(value, blocked)) {
+    count.replacements += 1;
+    return INDEXER_OUTPUT_REDACTION_MARKER;
+  }
+  if (typeof value === "string")
+    return redactText(value, blocked, count);
+  if (value === null || typeof value !== "object")
+    return value;
+  if (seen.has(value))
+    throw new TypeError("Indexer output redaction requires an acyclic value");
+  seen.add(value);
+  if (value instanceof Date) {
+    const redacted2 = redactText(value.toISOString(), blocked, count);
+    seen.delete(value);
+    return redacted2;
+  }
+  if (value instanceof Error) {
+    const redacted2 = {
+      name: redactText(value.name, blocked, count),
+      message: redactText(value.message, blocked, count)
+    };
+    seen.delete(value);
+    return redacted2;
+  }
+  if (Array.isArray(value)) {
+    const redacted2 = value.map((item) => redactStructured(item, blocked, count, seen));
+    seen.delete(value);
+    return redacted2;
+  }
+  const redacted = {};
+  for (const [key, item] of Object.entries(value)) {
+    const safeKey = redactText(key, blocked, count);
+    if (sensitiveKey(key, item)) {
+      count.replacements += 1;
+      redacted[safeKey] = INDEXER_OUTPUT_REDACTION_MARKER;
+    } else {
+      redacted[safeKey] = redactStructured(item, blocked, count, seen);
+    }
+  }
+  seen.delete(value);
+  return redacted;
+}
+function redactIndexerOutput(input) {
+  const count = { replacements: 0 };
+  const blocked = normalizedBlockedScalars(input.policy ?? {});
+  const value = typeof input.value === "string" ? redactText(input.value, blocked, count) : redactStructured(input.value, blocked, count, new WeakSet);
+  return {
+    value,
+    redacted: count.replacements > 0,
+    replacement_count: count.replacements
+  };
+}
+function redactIndexerOutputText(input) {
+  return redactIndexerOutput(input).value;
+}
+function assertIndexerOutputSafe(input) {
+  const result = redactIndexerOutput(input);
+  if (result.redacted) {
+    throw new TypeError(`Indexer ${input.channel} was blocked by the common output redaction boundary`);
+  }
+  return input.value;
+}
+
+// src/schemas/indexerEvidenceAdapterSchema.ts
+var digestSchema = exports_external.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var idSchema = exports_external.string().regex(/^[a-z0-9][a-z0-9._/-]*$/u).superRefine((value, context) => {
+  if (value.split("/").some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "must not contain empty, current-directory, or parent-directory segments"
+    });
+  }
+});
+var semverSchema = exports_external.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u);
+var canonicalRefSchema = exports_external.string().regex(/^[a-z][a-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9._~:/#@+-]*$/u);
+var packageCoordinateSchema = exports_external.string().regex(/^(?:@[a-z0-9._-]+\/)?[a-z0-9][a-z0-9._-]*$/u);
+var portablePathSchema = exports_external.string().superRefine((value, context) => {
+  const segments = value.split("/");
+  if (value.length === 0 || value.includes("\x00") || value.includes("\\") || value.startsWith("/") || /^[A-Za-z]:\//u.test(value) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "must be a portable relative path"
+    });
+  }
+});
+function addDuplicateIssues(values, context, field) {
+  const seen = new Set;
+  values.forEach((value, index) => {
+    if (seen.has(value)) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: `${field} must not contain duplicate value ${value}`,
+        path: [index]
+      });
+    }
+    seen.add(value);
+  });
+}
+var adapterIdentitySchema = exports_external.object({
+  id: idSchema,
+  package: packageCoordinateSchema,
+  export: exports_external.string().regex(/^[A-Za-z_$][A-Za-z0-9_$.-]*$/u),
+  version: semverSchema,
+  digest: digestSchema
+}).strict();
+var adapterLocatorSchema = exports_external.object({
+  source_ref: canonicalRefSchema,
+  module_ref: canonicalRefSchema.nullable(),
+  normalized_path: portablePathSchema,
+  qualified_item_path: exports_external.string().min(1).max(1024),
+  signature_digest: digestSchema
+}).strict();
+var indexerEvidenceAdapterFactSchema = exports_external.object({
+  fact_ref: canonicalRefSchema,
+  kind: idSchema,
+  locator: adapterLocatorSchema,
+  payload_digest: digestSchema,
+  denominator: exports_external.enum(["none", "eligible-file", "loc", "symbol", "protocol-item"])
+}).strict();
+var indexerEvidenceAdapterFileSchema = exports_external.object({
+  file_ref: canonicalRefSchema,
+  source_ref: canonicalRefSchema,
+  module_ref: canonicalRefSchema.nullable(),
+  normalized_path: portablePathSchema,
+  role: exports_external.enum(["primary-owner", "enricher"]),
+  coverage_tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
+  disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
+  facts: exports_external.array(indexerEvidenceAdapterFactSchema)
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.facts.map((fact2) => fact2.fact_ref), context, "facts");
+  if (value.disposition !== "analyzed" && value.facts.length > 0) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "unsupported or excluded files cannot publish facts",
+      path: ["facts"]
+    });
+  }
+  if ((value.role === "enricher" || value.coverage_tier === "lightweight-evidence") && value.facts.some((fact2) => fact2.denominator !== "none")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "enricher and lightweight evidence facts cannot contribute denominators",
+      path: ["facts"]
+    });
+  }
+});
+var toolchainStepSchema = exports_external.object({
+  step: idSchema,
+  package: packageCoordinateSchema,
+  export: exports_external.string().regex(/^[A-Za-z_$][A-Za-z0-9_$.-]*$/u),
+  version: semverSchema,
+  digest: digestSchema,
+  capabilities: exports_external.array(idSchema).min(1),
+  input_digest: digestSchema,
+  output_digest: digestSchema
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.capabilities, context, "capabilities");
+});
+var adapterDiagnosticSchema = exports_external.object({
+  code: idSchema,
+  fact_ref: canonicalRefSchema.optional(),
+  severity: exports_external.enum(["info", "warning", "error"]),
+  detail_digest: digestSchema
+}).strict();
+var indexerEvidenceAdapterResultSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.evidence-adapter-result/v1"),
+  adapter: adapterIdentitySchema,
+  authorized_scope: exports_external.object({
+    source_ref: canonicalRefSchema,
+    module_refs: exports_external.array(canonicalRefSchema),
+    scope_digest: digestSchema
+  }).strict(),
+  input_digest: digestSchema,
+  precedence: exports_external.number().int().nonnegative(),
+  files: exports_external.array(indexerEvidenceAdapterFileSchema).min(1),
+  diagnostics: exports_external.array(adapterDiagnosticSchema),
+  toolchain: exports_external.array(toolchainStepSchema).min(1),
+  output_digest: digestSchema
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.authorized_scope.module_refs, context, "authorized_scope.module_refs");
+  addDuplicateIssues(value.files.map((file) => file.file_ref), context, "files");
+  addDuplicateIssues(value.toolchain.map((step) => step.step), context, "toolchain");
+});
+var FACT_PAYLOADS = new WeakMap;
+function canonicalFactPayload(value, seen = new WeakSet, path = "$") {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("Indexer Evidence Adapter fact payload numbers must be finite");
+    }
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must contain only JSON values`);
+  }
+  if (seen.has(value)) {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must be acyclic`);
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const output2 = value.map((item, index) => canonicalFactPayload(item, seen, `${path}[${index}]`));
+    seen.delete(value);
+    return output2;
+  }
+  if (Object.prototype.toString.call(value) !== "[object Object]") {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must use plain JSON objects; received ${Object.prototype.toString.call(value)}`);
+  }
+  const output = {};
+  for (const [key, item] of Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+    output[key] = canonicalFactPayload(item, seen, `${path}.${key}`);
+  }
+  seen.delete(value);
+  return output;
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => [key, canonicalize(item)]));
+  }
+  return value;
+}
+function indexerEvidenceAdapterProtocolDigest(value) {
+  const canonical = JSON.stringify(canonicalize(value));
+  return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+}
+function indexerEvidenceAdapterFileRef(input) {
+  return `adapter-file:${indexerEvidenceAdapterProtocolDigest(input)}`;
+}
+function indexerEvidenceAdapterFactRef(input) {
+  return `adapter-fact:${indexerEvidenceAdapterProtocolDigest(input)}`;
+}
+function createIndexerEvidenceAdapterFact(input) {
+  const payload = canonicalFactPayload(input.payload);
+  const qualifiedItemPath = input.qualified_item_path.length <= 1024 ? input.qualified_item_path : `${input.qualified_item_path.slice(0, 950)}#${indexerEvidenceAdapterProtocolDigest(input.qualified_item_path)}`;
+  const locator = {
+    source_ref: input.source_ref,
+    module_ref: input.module_ref,
+    normalized_path: input.normalized_path,
+    qualified_item_path: qualifiedItemPath,
+    signature_digest: indexerEvidenceAdapterProtocolDigest(input.signature)
+  };
+  const fact2 = {
+    fact_ref: indexerEvidenceAdapterFactRef({ ...locator, kind: input.kind }),
+    kind: input.kind,
+    locator,
+    payload_digest: indexerEvidenceAdapterProtocolDigest(payload),
+    denominator: input.denominator
+  };
+  FACT_PAYLOADS.set(fact2, payload);
+  return fact2;
+}
+function indexerEvidenceAdapterFactPayloads(result) {
+  const payloads = result.files.flatMap((file) => file.facts.map((fact2) => {
+    const payload = FACT_PAYLOADS.get(fact2);
+    if (payload === undefined) {
+      throw new TypeError(`Evidence Adapter fact payload ${fact2.fact_ref} is no longer materialized in this process`);
+    }
+    if (indexerEvidenceAdapterProtocolDigest(payload) !== fact2.payload_digest) {
+      throw new TypeError(`Evidence Adapter fact payload ${fact2.fact_ref} is stale`);
+    }
+    return { fact_ref: fact2.fact_ref, payload };
+  })).sort((left, right) => compareCanonicalText(left.fact_ref, right.fact_ref));
+  return assertIndexerOutputSafe({ channel: "ipc-envelope", value: payloads });
+}
+function materializeIndexerEvidenceAdapterResult(result) {
+  return {
+    result,
+    fact_payloads: indexerEvidenceAdapterFactPayloads(result)
+  };
+}
+function indexerEvidenceAdapterOutputDigest(value) {
+  return indexerEvidenceAdapterProtocolDigest(value);
+}
+function compareCanonicalText(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function buildIndexerEvidenceAdapterResult(input) {
+  const canonical = {
+    ...input,
+    authorized_scope: {
+      ...input.authorized_scope,
+      module_refs: [...input.authorized_scope.module_refs].sort(compareCanonicalText)
+    },
+    files: input.files.map((file) => ({
+      ...file,
+      facts: [...file.facts].sort((left, right) => compareCanonicalText(left.fact_ref, right.fact_ref))
+    })).sort((left, right) => compareCanonicalText(left.file_ref, right.file_ref)),
+    diagnostics: [...input.diagnostics].sort((left, right) => compareCanonicalText(left.fact_ref ?? "", right.fact_ref ?? "") || compareCanonicalText(left.code, right.code) || compareCanonicalText(left.severity, right.severity) || compareCanonicalText(left.detail_digest, right.detail_digest)),
+    toolchain: input.toolchain.map((step) => ({
+      ...step,
+      capabilities: [...step.capabilities].sort(compareCanonicalText)
+    }))
+  };
+  const payloads = new Map;
+  for (const file of canonical.files) {
+    for (const fact2 of file.facts) {
+      const payload = FACT_PAYLOADS.get(fact2);
+      if (payload !== undefined)
+        payloads.set(fact2.fact_ref, payload);
+    }
+  }
+  const parsed = indexerEvidenceAdapterResultSchema.parse({
+    ...canonical,
+    output_digest: indexerEvidenceAdapterOutputDigest(canonical)
+  });
+  for (const file of parsed.files) {
+    for (const fact2 of file.facts) {
+      const payload = payloads.get(fact2.fact_ref);
+      if (payload !== undefined)
+        FACT_PAYLOADS.set(fact2, payload);
+    }
+  }
+  return assertIndexerOutputSafe({ channel: "success-payload", value: parsed });
+}
 // src/errors/c4aError.ts
 class C4AError extends Error {
   code;
@@ -13275,10 +13689,10 @@ function mapErrorCodeToStatus(code) {
   return ERROR_CODE_HTTP_STATUS[code] ?? 500;
 }
 // src/utils/id.ts
-import { createHash, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID } from "node:crypto";
 function generateId(type, parentId, name) {
   const input = `${type}:${parentId}:${name}`;
-  const hash = createHash("sha256").update(input).digest("hex");
+  const hash = createHash2("sha256").update(input).digest("hex");
   const hex32 = hash.slice(0, 32);
   return `${type}_${hex32}`;
 }
@@ -13286,9 +13700,9 @@ function generateUUID() {
   return randomUUID();
 }
 // src/utils/hash.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function contentHash(content) {
-  return createHash2("sha256").update(content).digest("hex");
+  return createHash3("sha256").update(content).digest("hex");
 }
 // src/utils/object.ts
 function isPlainObject(value) {
@@ -13494,7 +13908,15 @@ var DEFAULT_CONTENT_TYPES = [
   {
     id: "typescript",
     category: "code",
-    match: { extensions: [".ts", ".tsx"] },
+    match: { extensions: [".ts", ".tsx", ".mts", ".cts"] },
+    cas: { encoding: "utf8", hashInput: "content" },
+    pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCDC", renderer: "code" }
+  },
+  {
+    id: "javascript",
+    category: "code",
+    match: { extensions: [".js", ".jsx", ".mjs", ".cjs"] },
     cas: { encoding: "utf8", hashInput: "content" },
     pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
     display: { icon: "\uD83D\uDCDC", renderer: "code" }
@@ -13627,6 +14049,8 @@ export {
   resolvePathFilter,
   relationAtomSchema,
   relatedFactSchema,
+  redactIndexerOutputText,
+  redactIndexerOutput,
   productKindSchema,
   parseYaml,
   parseRef,
@@ -13637,6 +14061,7 @@ export {
   metricMilestoneSchema,
   metricAtomSchema,
   mergeDefaults,
+  materializeIndexerEvidenceAdapterResult,
   matchesPathFilter,
   mapErrorCodeToStatus,
   isVersionVisible,
@@ -13644,6 +14069,14 @@ export {
   isPlainObject,
   isPathSafe,
   isIndexableFile,
+  indexerEvidenceAdapterResultSchema,
+  indexerEvidenceAdapterProtocolDigest,
+  indexerEvidenceAdapterOutputDigest,
+  indexerEvidenceAdapterFileSchema,
+  indexerEvidenceAdapterFileRef,
+  indexerEvidenceAdapterFactSchema,
+  indexerEvidenceAdapterFactRef,
+  indexerEvidenceAdapterFactPayloads,
   hasExcludedSegment,
   groundingSchema,
   globToRegex,
@@ -13672,6 +14105,7 @@ export {
   decisionPhaseSchema,
   decisionAtomSchema,
   createPathMatcher,
+  createIndexerEvidenceAdapterFact,
   contentHash,
   constraintAtomSchema,
   comparisonDimensionValueSchema,
@@ -13679,9 +14113,11 @@ export {
   comparisonAtomSchema,
   buildSearchPrefix,
   buildRef,
+  buildIndexerEvidenceAdapterResult,
   boundaryAtomSchema,
   behaviorAtomSchema,
   attributeAtomSchema,
+  assertIndexerOutputSafe,
   Visibility,
   UPLOAD_MAX_FILE_SIZE,
   UPLOAD_MAX_FILES,
@@ -13696,6 +14132,7 @@ export {
   PathFilterConfigSchema,
   PackageKind,
   NodeType,
+  INDEXER_OUTPUT_REDACTION_MARKER,
   INDEXABLE_EXTENSIONS,
   INDEXABLE_DOC_EXTENSIONS,
   INDEXABLE_CODE_EXTENSIONS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/core",
-  "version": "0.6.19",
+  "version": "0.7.0",
   "type": "module",
   "description": "Shared extraction types, schemas, and utilities for Context",
   "license": "MIT",