@c4a/context 0.7.4 → 0.7.5

package/index.js

@@ -16661,6 +16661,53 @@ function indexerDependencyTargetMatches(input) {
   return input.target.level === "logical-unit" || input.target.artifact_kind === input.artifact_kind && (input.target.level === "artifact-kind" || input.target.section_key === input.section_key);
 }
 
+// src/indexerCompositionFactDependencies.ts
+function compositionFactDependencies(input) {
+  const composition = validateIndexerLayerCompositionInput(input.composition_input);
+  if (composition.workset_digest !== input.workset.workset_digest || composition.final_authority_layer_ref !== input.result.provider_layer_ref) {
+    throw new TypeError("extension composition belongs to another author run");
+  }
+  const selected = new Map(input.dependency_view.positive_nodes.flatMap((node) => node.kind === "selected-fact" ? [[node.fact_ref, node]] : []));
+  const spans = new Map(input.dependency_view.positive_nodes.flatMap((node) => node.kind === "source-span" ? [[node.node_ref, node]] : []));
+  return composition.accepted_fragments.flatMap((fragment) => {
+    if (fragment.payload.protocol !== "context.indexer.fragment.fact-enrichment/v1")
+      return [];
+    return fragment.payload.facts.map((fact) => {
+      if (fact.target_ref !== input.workset.logical_unit_ref) {
+        throw new TypeError("extension fact belongs to another logical unit");
+      }
+      const sourceSpanRefs = [...new Set(fact.evidence_refs.flatMap((ref) => {
+        const source = selected.get(ref.ref);
+        if (source === undefined) {
+          throw new TypeError(`extension fact references unavailable source fact ${ref.ref}`);
+        }
+        return source.source_span_node_refs;
+      }))].sort(compareIndexerCanonicalText);
+      const evidenceRefs = [...new Set(sourceSpanRefs.map((ref) => {
+        const span = spans.get(ref);
+        if (span === undefined)
+          throw new TypeError("extension fact has no authorized source span");
+        return span.evidence_ref;
+      }))].sort(compareIndexerCanonicalText);
+      const factRef = `layer-fact:${fragment.fragment_digest}/${fact.fact_id}`;
+      const node = {
+        kind: "selected-fact",
+        fact_ref: factRef,
+        fact_digest: indexerProtocolDigest({
+          fact_ref: factRef,
+          fact_kind: fact.fact_id,
+          subject_key: input.result.logical_unit.subject_key,
+          value: fact.value,
+          evidence_refs: evidenceRefs
+        }),
+        source_span_node_refs: sourceSpanRefs,
+        targets: []
+      };
+      return { ...node, node_ref: indexerDependencyNodeRef({ polarity: "positive", node }) };
+    });
+  });
+}
+
 // src/indexerRunProtocolCommon.ts
 var indexerRunFinalAuthoritySchema = exports_external.object({
   layer_ref: indexerProviderLayerRefSchema,
@@ -17221,7 +17268,15 @@ function buildIndexerArtifactDependencySet(input) {
     }
     return [evidence.evidence_ref, versionedPositive(node)];
   }));
-  const factNodes = dependencyView.positive_nodes.filter((node) => node.kind === "selected-fact");
+  const factNodes = [
+    ...dependencyView.positive_nodes.filter((node) => node.kind === "selected-fact"),
+    ...input.composition_input === undefined ? [] : compositionFactDependencies({
+      composition_input: input.composition_input,
+      workset: input.workset,
+      dependency_view: dependencyView,
+      result: input.result
+    })
+  ];
   const factNodeByRef = new Map(factNodes.map((node) => [node.fact_ref, node]));
   const factByRef = new Map(input.result.facts.map((fact) => {
     const node = factNodeByRef.get(fact.fact_ref);
@@ -17327,6 +17382,7 @@ function validateIndexerArtifactDependencySet(input) {
     workset: input.workset,
     run_envelope: input.run_envelope,
     dependency_view: input.dependency_view,
+    ...input.composition_input === undefined ? {} : { composition_input: input.composition_input },
     ...input.authorized_evidence_targets === undefined ? {} : { authorized_evidence_targets: input.authorized_evidence_targets }
   });
   if (canonicalIndexerJson(expected) !== canonicalIndexerJson(value)) {
@@ -18694,6 +18750,7 @@ function validateIndexerMainRunResult(input) {
       workset: request.workset,
       run_envelope: runEnvelope,
       dependency_view: input.validation.dependency_view,
+      composition_input: request.composition_input,
       ...input.validation.authorized_evidence_targets === undefined ? {} : {
         authorized_evidence_targets: input.validation.authorized_evidence_targets
       }
@@ -27471,33 +27528,124 @@ function observeIndexerMainWorksetState(input) {
   });
 }
 // src/indexerAgentStepProtocol.ts
-var indexerAgentStepInputSchema = exports_external.object({
-  protocol: exports_external.literal("context.indexer.agent-step-input/v1"),
-  run_request: indexerProgramRunRequestSchema,
+var indexerAgentStepTaskSchema = exports_external.object({
+  task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+  workset_digest: indexerDigestSchema,
+  execution_request_digest: indexerDigestSchema,
+  consumed_input_view_digest: indexerDigestSchema,
+  workset_view_resource_id: exports_external.string().regex(/^authorized-indexer-workset-view\/task-[0-9]{3}$/u),
+  workset_view_request_digest: indexerDigestSchema
+}).strict();
+var indexerMainAgentStepInputSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.agent-step-input/v2"),
+  stage: exports_external.enum(["partition", "author"]),
+  transport: indexerMainTransportBatchSchema,
+  instruction_request_digest: indexerDigestSchema,
+  tasks: exports_external.array(indexerAgentStepTaskSchema).min(1),
+  input_digest: indexerDigestSchema
+}).strict();
+var indexerPostAuthorAgentStepTaskSchema = exports_external.object({
+  task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+  workset_digest: indexerDigestSchema,
+  request_digest: indexerDigestSchema,
+  primary_result_view_digest: indexerDigestSchema,
+  workset_view_resource_id: exports_external.string().regex(/^authorized-indexer-workset-view\/task-[0-9]{3}$/u)
+}).strict();
+var indexerPostAuthorAgentStepInputSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.agent-step-input/v2"),
+  stage: exports_external.literal("post-author"),
   instruction_request_digest: indexerDigestSchema,
+  tasks: exports_external.array(indexerPostAuthorAgentStepTaskSchema).min(1),
   input_digest: indexerDigestSchema
 }).strict();
+var indexerAgentStepInputSchema = exports_external.discriminatedUnion("stage", [
+  indexerMainAgentStepInputSchema,
+  indexerPostAuthorAgentStepInputSchema
+]);
 function indexerAgentStepInputDigest(value) {
-  return indexerProtocolDigest(value);
+  const { input_digest: _digest, ...payload2 } = value;
+  return indexerProtocolDigest(payload2);
 }
 function buildIndexerAgentStepInput(input) {
-  const runRequest = validateIndexerProgramRunRequest(input.run_request);
+  if (input.run_requests.length === 0) {
+    throw new TypeError("Indexer Agent step requires at least one run request");
+  }
+  const runRequests = input.run_requests.map(validateIndexerProgramRunRequest);
+  if (input.workset_view_requests.length !== runRequests.length) {
+    throw new TypeError("Indexer Agent step must have one View per run request");
+  }
+  const stage = runRequests[0].workset.stage;
+  if (runRequests.some((request) => request.workset.stage !== stage)) {
+    throw new TypeError("Indexer Agent step batch must contain one stage");
+  }
+  const transport = buildIndexerMainTransportBatch(runRequests.map((request) => request.workset));
+  const tasks = runRequests.map((request, index) => {
+    const taskKey = `task-${String(index + 1).padStart(3, "0")}`;
+    const view = input.workset_view_requests[index];
+    if (view.workset_digest !== request.workset.workset_digest || view.resource_id !== `authorized-indexer-workset-view/${taskKey}`) {
+      throw new TypeError("Indexer Agent step View mapping does not match its workset");
+    }
+    return {
+      task_key: taskKey,
+      workset_digest: request.workset.workset_digest,
+      execution_request_digest: request.execution_request_digest,
+      consumed_input_view_digest: request.composition_input.view_digest,
+      workset_view_resource_id: view.resource_id,
+      workset_view_request_digest: view.request_digest
+    };
+  });
   const payload2 = {
-    protocol: "context.indexer.agent-step-input/v1",
-    run_request: runRequest,
-    instruction_request_digest: indexerDigestSchema.parse(input.instruction_request_digest)
+    protocol: "context.indexer.agent-step-input/v2",
+    stage,
+    transport,
+    instruction_request_digest: indexerDigestSchema.parse(input.instruction_request_digest),
+    tasks
   };
-  return indexerAgentStepInputSchema.parse({
+  return indexerMainAgentStepInputSchema.parse({
+    ...payload2,
+    input_digest: indexerAgentStepInputDigest(payload2)
+  });
+}
+function buildIndexerPostAuthorAgentStepInput(input) {
+  if (input.fragment_requests.length === 0) {
+    throw new TypeError("post-author Agent step requires at least one fragment request");
+  }
+  const requests = input.fragment_requests.map(validateIndexerPostAuthorFragmentRequest);
+  const tasks = requests.map((request, index) => {
+    const taskKey = `task-${String(index + 1).padStart(3, "0")}`;
+    return {
+      task_key: taskKey,
+      workset_digest: request.workset.workset_digest,
+      request_digest: request.request_digest,
+      primary_result_view_digest: request.primary_result_view.view_digest,
+      workset_view_resource_id: `authorized-indexer-workset-view/${taskKey}`
+    };
+  });
+  const payload2 = {
+    protocol: "context.indexer.agent-step-input/v2",
+    stage: "post-author",
+    instruction_request_digest: indexerDigestSchema.parse(input.instruction_request_digest),
+    tasks
+  };
+  return indexerPostAuthorAgentStepInputSchema.parse({
     ...payload2,
     input_digest: indexerAgentStepInputDigest(payload2)
   });
 }
 function validateIndexerAgentStepInput(value) {
   const input = indexerAgentStepInputSchema.parse(value);
-  const rebuilt = buildIndexerAgentStepInput(input);
-  if (rebuilt.input_digest !== input.input_digest) {
+  if (input.input_digest !== indexerAgentStepInputDigest(input)) {
     throw new TypeError("Indexer Agent step input digest is invalid");
   }
+  if (input.stage === "post-author") {
+    if (new Set(input.tasks.map((task) => task.task_key)).size !== input.tasks.length) {
+      throw new TypeError("post-author Agent step task keys must be unique");
+    }
+    return input;
+  }
+  if (input.transport.worksets.length !== input.tasks.length || input.transport.worksets.some((workset, index) => workset.stage !== input.stage || workset.workset_digest !== input.tasks[index].workset_digest)) {
+    throw new TypeError("Indexer Agent step transport does not match its task manifest");
+  }
   return input;
 }
 // src/indexerSemanticInput.ts
@@ -27525,9 +27673,6 @@ var indexerProviderResolutionSemanticInputSchema = exports_external.object({
     value: exports_external.unknown()
   }).strict().optional()
 }).strict();
-var indexerProviderFinalizationSemanticInputSchema = exports_external.object({
-  stage: exports_external.literal("provider-finalization")
-}).strict();
 var indexerProviderProgramAuthorizationSemanticInputSchema = exports_external.object({
   stage: exports_external.literal("provider-program-authorization"),
   decision: exports_external.enum(["approved", "rejected"])
@@ -27565,8 +27710,6 @@ var partitionUnsupportedSchema = exports_external.object({
 var completePartitionInputSchema = exports_external.object({
   stage: exports_external.literal("partition"),
   outcome: exports_external.literal("complete"),
-  unit_type: exports_external.string().min(1),
-  partition_axis: exports_external.string().min(1),
   groups: exports_external.array(partitionGroupSchema2),
   excluded: exports_external.array(partitionDispositionSchema).default([]),
   unsupported: exports_external.array(partitionUnsupportedSchema).default([])
@@ -27574,8 +27717,6 @@ var completePartitionInputSchema = exports_external.object({
 var failedPartitionInputSchema = exports_external.object({
   stage: exports_external.literal("partition"),
   outcome: exports_external.literal("failed"),
-  unit_type: exports_external.string().min(1),
-  partition_axis: exports_external.string().min(1),
   groups: exports_external.array(partitionGroupSchema2).default([]),
   excluded: exports_external.array(partitionDispositionSchema).default([]),
   unsupported: exports_external.array(partitionUnsupportedSchema).default([]),
@@ -27663,6 +27804,45 @@ var indexerAuthorSemanticInputSchema = exports_external.object({
     });
   }
 });
+var indexerPartitionBatchSemanticInputSchema = exports_external.object({
+  stage: exports_external.literal("partition"),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+    result: indexerPartitionSemanticInputSchema
+  }).strict()).min(1)
+}).strict().superRefine((value, context) => {
+  const keys = value.results.map((result) => result.task_key);
+  if (new Set(keys).size !== keys.length) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["results"],
+      message: "partition batch task keys must be unique"
+    });
+  }
+});
+var indexerAuthorBatchSemanticInputSchema = exports_external.object({
+  stage: exports_external.literal("author"),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+    result: indexerAuthorSemanticInputSchema
+  }).strict()).min(1)
+}).strict().superRefine((value, context) => {
+  const keys = value.results.map((result) => result.task_key);
+  if (new Set(keys).size !== keys.length) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["results"],
+      message: "author batch task keys must be unique"
+    });
+  }
+});
+var indexerMainBatchSubmissionEnvelopeSchema = exports_external.object({
+  stage: exports_external.enum(["partition", "author", "post-author"]),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string(),
+    result: exports_external.unknown()
+  }).strict()).min(1)
+}).strict();
 var postAuthorSectionSchema = exports_external.object({
   key: exports_external.string().min(1),
   heading: exports_external.string().min(1),
@@ -27689,6 +27869,22 @@ var indexerPostAuthorSemanticInputSchema = exports_external.object({
     });
   }
 });
+var indexerPostAuthorBatchSemanticInputSchema = exports_external.object({
+  stage: exports_external.literal("post-author"),
+  results: exports_external.array(exports_external.object({
+    task_key: exports_external.string().regex(/^task-[0-9]{3}$/u),
+    result: indexerPostAuthorSemanticInputSchema
+  }).strict()).min(1)
+}).strict().superRefine((value, context) => {
+  const keys = value.results.map((result) => result.task_key);
+  if (new Set(keys).size !== keys.length) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["results"],
+      message: "post-author batch task keys must be unique"
+    });
+  }
+});
 var indexerStructureReviewInputSchema = exports_external.object({
   stage: exports_external.literal("structure-review"),
   decision: exports_external.enum(["approved", "request-adjustment"]),
@@ -27705,7 +27901,11 @@ var indexerStructureReviewInputSchema = exports_external.object({
 var indexerLayoutConfirmationInputSchema = exports_external.object({
   stage: exports_external.literal("layout-confirmation"),
   decision: exports_external.enum(["approved", "rejected"]),
-  feedback: exports_external.string().min(1).optional()
+  feedback: exports_external.string().min(1).optional(),
+  paths: exports_external.array(exports_external.object({
+    artifact_ref: exports_external.string().min(1),
+    output_path: exports_external.string().min(1)
+  }).strict()).min(1).optional()
 }).strict().superRefine((value, context) => {
   if (value.decision === "rejected" && value.feedback === undefined) {
     context.addIssue({
@@ -27714,21 +27914,33 @@ var indexerLayoutConfirmationInputSchema = exports_external.object({
       message: "rejected layout confirmation requires feedback"
     });
   }
+  if (value.decision === "rejected" && value.paths !== undefined) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["paths"],
+      message: "only an approved layout can select output paths"
+    });
+  }
 });
 var indexerCurrentActionInputSchema = exports_external.union([
   indexerProviderSelectionSemanticInputSchema,
   indexerProviderResolutionSemanticInputSchema,
   indexerProviderProgramAuthorizationSemanticInputSchema,
-  indexerProviderFinalizationSemanticInputSchema,
-  indexerPartitionSemanticInputSchema,
-  indexerAuthorSemanticInputSchema,
-  indexerPostAuthorSemanticInputSchema,
+  indexerPartitionBatchSemanticInputSchema,
+  indexerAuthorBatchSemanticInputSchema,
+  indexerPostAuthorBatchSemanticInputSchema,
   indexerStructureReviewInputSchema,
   indexerLayoutConfirmationInputSchema
 ]);
 function validateIndexerCurrentActionInput(value) {
   return indexerCurrentActionInputSchema.parse(value);
 }
+function parseIndexerCurrentActionSubmission(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && (Reflect.get(value, "stage") === "partition" || Reflect.get(value, "stage") === "author" || Reflect.get(value, "stage") === "post-author")) {
+    return indexerMainBatchSubmissionEnvelopeSchema.parse(value);
+  }
+  return validateIndexerCurrentActionInput(value);
+}
 // src/indexerExampleIdentity.ts
 var exampleObservationSchema = exports_external.object({
   observation_ref: indexerCanonicalRefSchema,
@@ -29542,6 +29754,10 @@ function viewRef(currentArtifactRef, collection) {
   })}`;
 }
 function readerPathSlug(value) {
+  const identity2 = value.trim();
+  if (/^(?:artifact|evidence|node|section|view):/iu.test(identity2) || /(?:^|[:/_-])sha256(?::|$)/iu.test(identity2) || /^[a-f\d]{32,}$/iu.test(identity2) || /^\d{8,14}$/u.test(identity2) || /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/iu.test(identity2)) {
+    throw new TypeError("layout resolver rejects machine identity in a reader-facing path");
+  }
   const slug = value.normalize("NFC").replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1-$2").replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1-$2").toLowerCase().replace(/[^\p{Letter}\p{Number}]+/gu, "-").replace(/^-+|-+$/gu, "");
   if (slug.length === 0) {
     throw new TypeError("layout resolver requires a reader-readable semantic path identity");
@@ -29549,8 +29765,10 @@ function readerPathSlug(value) {
   return slug;
 }
 function outputPath(input) {
-  const moduleIdentity = input.module_ref?.replace(/^module:/u, "") ?? input.subject_key.namespace;
-  return `knowledge/${input.collection}/${readerPathSlug(moduleIdentity)}/${readerPathSlug(input.artifact_id)}.md`;
+  const namespace = readerPathSlug(input.subject_key.namespace);
+  const subject = readerPathSlug(input.subject_key.local_key);
+  const suffix = input.primary ? "" : input.duplicate_kind ? `-${readerPathSlug(input.artifact.artifact_kind)}-${readerPathSlug(input.artifact.artifact_id)}` : `-${readerPathSlug(input.artifact.artifact_kind)}`;
+  return `knowledge/${input.collection}/${namespace}/${subject}${suffix}.md`;
 }
 function structuredSections(artifact, facts) {
   return artifact.sections.map((section) => {
@@ -29657,6 +29875,11 @@ function resolveIndexerLayout(input) {
   if (bundleById.size !== (artifactBundle?.artifacts.length ?? 0) || bundleById.size !== effective.artifacts.length) {
     throw new TypeError("layout resolver requires one Artifact Bundle entry per Artifact");
   }
+  const requiredArtifactIds = new Set((artifactBundle?.artifacts ?? []).filter((artifact) => artifact.purpose === "required").map((artifact) => artifact.artifact_id));
+  const artifactKindCounts = new Map;
+  for (const artifact of effective.artifacts) {
+    artifactKindCounts.set(artifact.artifact_kind, (artifactKindCounts.get(artifact.artifact_kind) ?? 0) + 1);
+  }
   const artifacts = effective.artifacts.map((artifact) => {
     const bundleEntry = bundleById.get(artifact.artifact_id);
     if (bundleEntry === undefined || bundleEntry.artifact_kind !== artifact.artifact_kind) {
@@ -29702,9 +29925,10 @@ function resolveIndexerLayout(input) {
       collection,
       output_path: outputPath({
         collection,
-        module_ref: result.module_ref,
         subject_key: result.logical_unit.subject_key,
-        artifact_id: artifact.artifact_id
+        artifact,
+        primary: effective.artifacts.length === 1 || requiredArtifactIds.size === 1 && requiredArtifactIds.has(artifact.artifact_id),
+        duplicate_kind: (artifactKindCounts.get(artifact.artifact_kind) ?? 0) > 1
       }),
       shared_artifact_fingerprint_digest: sharedFingerprint.fingerprint_digest,
       purpose: bundleEntry.purpose,
@@ -31799,17 +32023,38 @@ function replaceEntry(input) {
   return buildLedger({ workset_set: input.ledger.workset_set, entries });
 }
 function startIndexerMainRun(input) {
+  return startIndexerMainRuns({
+    ledger: input.ledger,
+    workset_digests: [input.workset_digest]
+  });
+}
+function startIndexerMainRuns(input) {
   const ledger = validateIndexerMainRunLedger(input.ledger);
-  return replaceEntry({
-    ledger,
-    workset_digest: input.workset_digest,
-    replace: (entry) => {
-      if (entry.state !== "pending" && entry.state !== "stale") {
-        throw new TypeError("only pending or stale main work may start");
-      }
+  if (input.workset_digests.length === 0) {
+    throw new TypeError("main run batch must contain at least one workset");
+  }
+  const requested = new Set(input.workset_digests);
+  if (requested.size !== input.workset_digests.length) {
+    throw new TypeError("main run batch contains duplicate worksets");
+  }
+  const selected = ledger.entries.filter((entry) => requested.has(entry.workset_digest));
+  if (selected.length !== requested.size) {
+    throw new TypeError("main run ledger has no requested workset");
+  }
+  if (new Set(selected.map((entry) => entry.stage)).size !== 1) {
+    throw new TypeError("main run batch must contain one stage");
+  }
+  if (selected.some((entry) => entry.state !== "pending" && entry.state !== "stale")) {
+    throw new TypeError("only pending or stale main work may start");
+  }
+  return buildLedger({
+    workset_set: ledger.workset_set,
+    entries: ledger.entries.map((entry) => {
+      if (!requested.has(entry.workset_digest))
+        return entry;
       const clean = Object.fromEntries(Object.entries(entry).filter(([key]) => key !== "state" && key !== "previous_workset_digest" && key !== "previous_execution_request_digest"));
       return { ...clean, state: "running" };
-    }
+    })
   });
 }
 function acceptIndexerMainRun(input) {
@@ -33375,6 +33620,7 @@ export {
   validateAndRecordIndexerMainRun,
   validateAndMaterializeIndexerLayerFragment,
   startIndexerPostAuthorRun,
+  startIndexerMainRuns,
   startIndexerMainRun,
   source,
   sameIndexerParserExecutionPlan,
@@ -33410,6 +33656,7 @@ export {
   planIndexerPostAuthorComposition,
   parseIndexerRegistry,
   parseIndexerProviderManifest,
+  parseIndexerCurrentActionSubmission,
   ownerCells,
   observeIndexerPostAuthorState,
   observeIndexerMainWorksetState,
@@ -33538,7 +33785,6 @@ export {
   indexerProviderManifestSchema,
   indexerProviderLayerRefSchema,
   indexerProviderLayerFragmentSchema,
-  indexerProviderFinalizationSemanticInputSchema,
   indexerProviderCompositionPlanSchema,
   indexerProviderBundleIntegrity,
   indexerProtocolDigest,
@@ -33830,6 +34076,7 @@ export {
   buildIndexerPrimaryRegistryProjection,
   buildIndexerPrimaryExecutionProjection,
   buildIndexerPostAuthorFragmentRequest,
+  buildIndexerPostAuthorAgentStepInput,
   buildIndexerPartitionInventoryFromParserFactView,
   buildIndexerParserWorksetViewSource,
   buildIndexerParserResolutionLocks,