Skip to content

armgit / hypit

Public Imported from GitHub
0

Clone any viral video with AI agents. Not just a script, the whole workflow: swap the face, the words, the B-roll, ship 100 variants in one command, and get your 100M views.

refactor(v2): separate candidates from satisfactions

kashorin93458649d96a
diff --git a/packages/cli/src/main.ts b/packages/cli/src/main.ts
index a5a9f85f..535c2493 100644
--- a/packages/cli/src/main.ts
+++ b/packages/cli/src/main.ts
@@ -5,7 +5,7 @@ import { pathToFileURL } from "node:url";
import type { LocalRuntime } from "@svml/local";
import { isDigest } from "@svml/protocol";
import {
- createHistoricalCandidate,
+ createBuildRecordCandidate,
sealRealizationOverlay,
} from "@svml/realization";
import {
@@ -309,7 +309,7 @@ export async function runCli(argv: readonly string[], io: CliIo): Promise<void>
const compilation = await compiler.compileFile(args.file!);
const seen = new Set<string>();
const candidates = [];
- const bindings = [];
+ const satisfactions = [];
const summary = [];
for (const pin of args.pins) {
if (seen.has(pin.output)) throw new Error(`--pin repeats output ${pin.output}`);
@@ -321,13 +321,12 @@ export async function runCli(argv: readonly string[], io: CliIo): Promise<void>
}
const historical = await runtime.status(pin.build);
if (historical.build === undefined) throw new Error(`--pin source Build ${pin.build} does not exist`);
- const candidate = createHistoricalCandidate({
- source: compilation.elaboration.graph,
+ const candidate = createBuildRecordCandidate({
build: historical.build.state,
- output: exported.ref.id,
+ sourceOutput: exported.ref.id,
});
candidates.push(candidate);
- bindings.push({ output: exported.ref.id, candidate: candidate.id });
+ satisfactions.push({ output: exported.ref.id, candidate: candidate.id, fidelity: "substitute" as const });
summary.push({ output: pin.output, build: pin.build, candidate: candidate.id });
}
const overlay = sealRealizationOverlay({
@@ -338,7 +337,7 @@ export async function runCli(argv: readonly string[], io: CliIo): Promise<void>
pinSummary = summary;
return compiler.planCompilation(compilation, {
...planOptions,
- bindings,
+ satisfactions,
realizations: [overlay],
});
})();
diff --git a/packages/compiler-node/src/compiler.ts b/packages/compiler-node/src/compiler.ts
index b7b48c36..b089ae55 100644
--- a/packages/compiler-node/src/compiler.ts
+++ b/packages/compiler-node/src/compiler.ts
@@ -20,7 +20,7 @@ import type {
BuildPlan,
BuildRequest,
BuildState,
- CandidateBinding,
+ Satisfaction,
NeedAcceptance,
} from "@svml/protocol";
import { resolveRealization } from "@svml/realization";
@@ -88,7 +88,7 @@ export type NodeCompilerOptions = {
export type PlanFileOptions = {
readonly targets: readonly string[];
readonly accepts?: NeedAcceptance;
- readonly bindings?: readonly CandidateBinding[];
+ readonly satisfactions?: readonly Satisfaction[];
readonly implementationClosure?: import("@svml/protocol").Digest;
/** External Candidate attachments; never discovered from the author source. */
readonly realizations?: readonly RealizationOverlay[];
@@ -193,7 +193,7 @@ export class NodeCompiler {
? {}
: { implementationClosure: options.implementationClosure }),
targets,
- bindings: options.bindings ?? [],
+ satisfactions: options.satisfactions ?? [],
});
const state = start(
compilation.program,
diff --git a/packages/core/README.md b/packages/core/README.md
index 1fc1e06a..653a8c5d 100644
--- a/packages/core/README.md
+++ b/packages/core/README.md
@@ -3,9 +3,11 @@
Experimental v2 bootstrap microkernel.
The package accepts an already resolved module closure, typed authored modules, a complete
-`svml.graph@1` and a `svml.build-request@1`. It verifies Candidate selection and compiles the finite
+`svml.graph@2` and a `svml.build-request@2`. It verifies explicit Satisfaction and compiles the finite
BuildPlan by traversing backwards from every Target, resolving Logical Outputs and memoizing shared
-atomic Operations by stable OperationId. It then validates immutable Records, Needs, Receipts and
+atomic Operations by stable OperationId during compilation. The BuildPlan is frozen before any
+external Command; execution performs no Candidate selection, graph mutation or content-based
+deduplication. It then validates immutable Records, Needs, Receipts and
Derivations and advances a serializable `BuildState` with pure `reduce(state, event)` calls.
Derivations bind Producer and implementation identity, input/output Record digests, Need request
diff --git a/packages/core/src/graph.ts b/packages/core/src/graph.ts
index 77013392..cc88d4bd 100644
--- a/packages/core/src/graph.ts
+++ b/packages/core/src/graph.ts
@@ -1,15 +1,16 @@
import type {
BuildRequest,
Candidate,
- CandidateBinding,
CandidateRoot,
CompiledGraph,
+ Conformance,
GraphValueRef,
LinkedProgram,
LogicalOutput,
OperationNode,
OperationResult,
ProducerRef,
+ Satisfaction,
StoredValue,
TypeRef,
} from "@svml/protocol";
@@ -20,7 +21,7 @@ import { resolveProducer, sealRecord, verifyRecord } from "./link.js";
import { producerKey, sameType, typeKey } from "./reference.js";
export const EMPTY_REALIZATION_DIGEST = digestOf({
- format: "svml.realization-closure@1",
+ format: "svml.realization-closure@2",
overlays: [],
});
@@ -59,7 +60,6 @@ function normalizeOutput(output: LogicalOutput): LogicalOutput {
id: output.id,
type: output.type,
primary: output.primary,
- candidates: [...output.candidates].sort(),
semanticInputs: [...output.semanticInputs].map(normalizeRef).sort((a, b) =>
valueRefKey(a).localeCompare(valueRefKey(b))),
};
@@ -80,9 +80,8 @@ function normalizeOutput(output: LogicalOutput): LogicalOutput {
function normalizeCandidate(candidate: Candidate): Candidate {
return {
id: candidate.id,
- output: candidate.output,
+ type: candidate.type,
root: normalizeRoot(candidate.root),
- fidelity: candidate.fidelity,
};
}
@@ -122,10 +121,10 @@ export function sealCompiledGraph(
candidates: [...graph.candidates].map(normalizeCandidate).sort((a, b) => a.id.localeCompare(b.id)),
operations: [...graph.operations].map(normalizeOperation).sort((a, b) => a.id.localeCompare(b.id)),
};
- const source = graph.source ?? digestOf({ format: "svml.graph-source@1", ...normalized });
+ const source = graph.source ?? digestOf({ format: "svml.graph-source@2", ...normalized });
const realization = graph.realization ?? EMPTY_REALIZATION_DIGEST;
const content = {
- format: "svml.graph@1" as const,
+ format: "svml.graph@2" as const,
...normalized,
source,
realization,
@@ -139,17 +138,21 @@ export function sealBuildRequest(
const targets = [...request.targets]
.map((target) => ({ output: target.output, accepts: target.accepts }))
.sort((a, b) => a.output.localeCompare(b.output));
- const bindings = [...request.bindings]
- .map((binding) => ({ output: binding.output, candidate: binding.candidate }))
+ const satisfactions = [...request.satisfactions]
+ .map((satisfaction) => ({
+ output: satisfaction.output,
+ candidate: satisfaction.candidate,
+ fidelity: satisfaction.fidelity,
+ }))
.sort((a, b) => a.output.localeCompare(b.output));
const content = {
- format: "svml.build-request@1" as const,
+ format: "svml.build-request@2" as const,
graph: request.graph,
...(request.implementationClosure === undefined
? {}
: { implementationClosure: request.implementationClosure }),
targets,
- bindings,
+ satisfactions,
};
return { ...content, digest: digestOf(content) };
}
@@ -172,30 +175,30 @@ export function resolveOperation(graph: CompiledGraph, id: string): OperationNod
return operation;
}
-export function bindingForOutput(
+export function satisfactionForOutput(
request: BuildRequest,
output: string,
-): CandidateBinding | undefined {
- return request.bindings.find((binding) => binding.output === output);
+): Satisfaction | undefined {
+ return request.satisfactions.find((satisfaction) => satisfaction.output === output);
}
-export function selectedCandidate(
+/** @deprecated Use satisfactionForOutput. */
+export const bindingForOutput = satisfactionForOutput;
+
+export function selectedSatisfaction(
graph: CompiledGraph,
request: BuildRequest,
outputId: string,
-): Candidate {
+): { readonly candidate: Candidate; readonly fidelity: Conformance } {
const output = resolveLogicalOutput(graph, outputId);
- const binding = bindingForOutput(request, outputId);
- const candidate = resolveCandidate(graph, binding?.candidate ?? output.primary);
- invariant(
- candidate.output === output.id,
- "CANDIDATE_OUTPUT_MISMATCH",
- `${candidate.id} cannot realize ${output.id}`,
- candidate.id,
- );
- return candidate;
+ const satisfaction = satisfactionForOutput(request, outputId);
+ const candidate = resolveCandidate(graph, satisfaction?.candidate ?? output.primary);
+ return { candidate, fidelity: satisfaction?.fidelity ?? "exact" };
}
+/** @deprecated Use selectedSatisfaction. */
+export const selectedCandidate = selectedSatisfaction;
+
export function operationResultRecord(operation: OperationNode): string {
return operation.result.record;
}
@@ -322,16 +325,22 @@ function semanticLeaves(graph: CompiledGraph, root: CandidateRoot): Set<string>
return leaves;
}
-function candidateType(program: LinkedProgram, graph: CompiledGraph, candidate: Candidate): TypeRef {
- const output = resolveLogicalOutput(graph, candidate.output);
+function verifyCandidateValue(program: LinkedProgram, graph: CompiledGraph, candidate: Candidate): void {
if (candidate.root.kind === "operation") {
- return operationResultType(program, resolveOperation(graph, candidate.root.result.operation));
+ const supplied = operationResultType(program, resolveOperation(graph, candidate.root.result.operation));
+ invariant(
+ sameType(supplied, candidate.type),
+ "CANDIDATE_RESULT_TYPE_MISMATCH",
+ `${candidate.id} declares ${typeKey(candidate.type)} but returns ${typeKey(supplied)}`,
+ candidate.id,
+ );
+ return;
}
const provisional = sealRecord({
id: candidate.root.value.id,
- type: output.type,
+ type: candidate.type,
value: candidate.root.value.value,
- conformance: candidate.fidelity,
+ conformance: "substitute",
origin: {
kind: "provided",
candidate: candidate.id,
@@ -345,11 +354,40 @@ function candidateType(program: LinkedProgram, graph: CompiledGraph, candidate:
: { validation: candidate.root.value.validation }),
});
verifyRecord(program.closure, provisional);
- return provisional.type;
+}
+
+function verifySatisfaction(
+ program: LinkedProgram,
+ graph: CompiledGraph,
+ output: LogicalOutput,
+ candidate: Candidate,
+ fidelity: Conformance,
+): void {
+ invariant(
+ fidelity === "exact" || fidelity === "substitute",
+ "INVALID_CONFORMANCE",
+ `${candidate.id} satisfaction fidelity is invalid`,
+ candidate.id,
+ );
+ invariant(
+ sameType(candidate.type, output.type),
+ "CANDIDATE_RESULT_TYPE_MISMATCH",
+ `${candidate.id} supplies ${typeKey(candidate.type)}, not ${typeKey(output.type)}`,
+ candidate.id,
+ );
+ const allowed = new Set(output.semanticInputs.map(valueRefKey));
+ for (const leaf of semanticLeaves(graph, candidate.root)) {
+ invariant(
+ allowed.has(leaf),
+ "CANDIDATE_EXCEEDS_SEMANTIC_ENVELOPE",
+ `${candidate.id} depends on ${leaf} outside ${output.id}'s Semantic Input Envelope`,
+ candidate.id,
+ );
+ }
}
export function verifyCompiledGraph(program: LinkedProgram, graph: CompiledGraph): void {
- invariant(graph.format === "svml.graph@1", "UNSUPPORTED_GRAPH", "unsupported compiled graph format");
+ invariant(graph.format === "svml.graph@2", "UNSUPPORTED_GRAPH", "unsupported compiled graph format");
invariant(isDigest(graph.id), "INVALID_DIGEST", "compiled graph id is invalid");
invariant(isDigest(graph.source), "INVALID_DIGEST", "compiled graph source digest is invalid");
invariant(isDigest(graph.realization), "INVALID_DIGEST", "compiled graph realization digest is invalid");
@@ -363,7 +401,7 @@ export function verifyCompiledGraph(program: LinkedProgram, graph: CompiledGraph
if (graph.realization === EMPTY_REALIZATION_DIGEST) {
invariant(
graph.source === digestOf({
- format: "svml.graph-source@1",
+ format: "svml.graph-source@2",
program: graph.program,
outputs: graph.outputs,
candidates: graph.candidates,
@@ -422,52 +460,12 @@ export function verifyCompiledGraph(program: LinkedProgram, graph: CompiledGraph
invariant(candidate.id.length > 0, "EMPTY_CANDIDATE_ID", "Candidate id is empty");
invariant(!candidateIds.has(candidate.id), "DUPLICATE_CANDIDATE", `duplicate ${candidate.id}`, candidate.id);
candidateIds.add(candidate.id);
- const output = resolveLogicalOutput(graph, candidate.output);
- invariant(
- output.candidates.includes(candidate.id),
- "CANDIDATE_NOT_EXPOSED",
- `${candidate.id} is not exposed by ${output.id}`,
- candidate.id,
- );
- invariant(
- candidate.fidelity === "exact" || candidate.fidelity === "substitute",
- "INVALID_CONFORMANCE",
- `${candidate.id} fidelity is invalid`,
- );
- const supplied = candidateType(program, graph, candidate);
- invariant(
- sameType(supplied, output.type),
- "CANDIDATE_RESULT_TYPE_MISMATCH",
- `${candidate.id} returns ${typeKey(supplied)}, not ${typeKey(output.type)}`,
- candidate.id,
- );
- const allowed = new Set(output.semanticInputs.map(valueRefKey));
- for (const leaf of semanticLeaves(graph, candidate.root)) {
- invariant(
- allowed.has(leaf),
- "CANDIDATE_EXCEEDS_SEMANTIC_ENVELOPE",
- `${candidate.id} depends on ${leaf} outside ${output.id}'s Semantic Input Envelope`,
- candidate.id,
- );
- }
+ verifyCandidateValue(program, graph, candidate);
}
for (const output of graph.outputs) {
- invariant(output.candidates.length > 0, "OUTPUT_WITHOUT_CANDIDATE", `${output.id} has no Candidates`);
- invariant(
- new Set(output.candidates).size === output.candidates.length,
- "DUPLICATE_OUTPUT_CANDIDATE",
- `${output.id} repeats a Candidate`,
- output.id,
- );
const primary = resolveCandidate(graph, output.primary);
- invariant(primary.output === output.id, "PRIMARY_OUTPUT_MISMATCH", `${output.id} Primary belongs elsewhere`);
- invariant(output.candidates.includes(primary.id), "PRIMARY_NOT_EXPOSED", `${output.id} omits its Primary`);
- invariant(primary.fidelity === "exact", "PRIMARY_NOT_EXACT", `${output.id} Primary must be exact`);
- for (const id of output.candidates) {
- const candidate = resolveCandidate(graph, id);
- invariant(candidate.output === output.id, "CANDIDATE_OUTPUT_MISMATCH", `${id} belongs elsewhere`);
- }
+ verifySatisfaction(program, graph, output, primary, "exact");
}
}
@@ -478,7 +476,7 @@ export function verifyBuildRequest(
): void {
verifyCompiledGraph(program, graph);
invariant(
- request.format === "svml.build-request@1",
+ request.format === "svml.build-request@2",
"UNSUPPORTED_BUILD_REQUEST",
"unsupported BuildRequest format",
);
@@ -505,13 +503,13 @@ export function verifyBuildRequest(
targets.add(target.output);
}
- const bindings = new Set<string>();
- for (const binding of request.bindings) {
- const output = resolveLogicalOutput(graph, binding.output);
- invariant(!bindings.has(output.id), "DUPLICATE_CANDIDATE_BINDING", `${output.id} is bound twice`);
- const candidate = resolveCandidate(graph, binding.candidate);
- invariant(candidate.output === output.id, "CANDIDATE_OUTPUT_MISMATCH", `${candidate.id} cannot realize ${output.id}`);
- bindings.add(output.id);
+ const satisfactions = new Set<string>();
+ for (const satisfaction of request.satisfactions) {
+ const output = resolveLogicalOutput(graph, satisfaction.output);
+ invariant(!satisfactions.has(output.id), "DUPLICATE_SATISFACTION", `${output.id} is satisfied twice`);
+ const candidate = resolveCandidate(graph, satisfaction.candidate);
+ verifySatisfaction(program, graph, output, candidate, satisfaction.fidelity);
+ satisfactions.add(output.id);
}
}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 1dcb9389..b4386e0b 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -33,6 +33,8 @@ export {
sealBuildRequest,
sealCompiledGraph,
selectedCandidate,
+ selectedSatisfaction,
+ satisfactionForOutput,
valueRefKey,
verifyBuildRequest,
verifyCompiledGraph,
diff --git a/packages/core/src/plan.ts b/packages/core/src/plan.ts
index 6adef214..53525368 100644
--- a/packages/core/src/plan.ts
+++ b/packages/core/src/plan.ts
@@ -18,7 +18,7 @@ import {
operationResultRecord,
resolveLogicalOutput,
resolveOperation,
- selectedCandidate,
+ selectedSatisfaction,
verifyBuildRequest,
} from "./graph.js";
import { resolveProducer, sealRecord, verifyRecord } from "./link.js";
@@ -79,7 +79,7 @@ function planContent(
selections: BuildPlan["selections"],
): Omit<BuildPlan, "id"> {
return {
- format: "svml.plan@1",
+ format: "svml.plan@2",
graph: graph.id,
request: request.digest,
initialValues,
@@ -148,14 +148,15 @@ export function compileBuild(
invariant(!resolvingOutputs.has(id), "SELECTED_GRAPH_CYCLE", `selected graph cycles through ${id}`, id);
resolvingOutputs.add(id);
const output = resolveLogicalOutput(graph, id);
- const candidate = selectedCandidate(graph, request, id);
+ const selected = selectedSatisfaction(graph, request, id);
+ const { candidate, fidelity } = selected;
let resolved: ResolvedSource;
if (candidate.root.kind === "value") {
const record = sealRecord({
id: candidate.root.value.id,
- type: output.type,
+ type: candidate.type,
value: candidate.root.value.value,
- conformance: candidate.fidelity,
+ conformance: fidelity,
origin: {
kind: "provided",
candidate: candidate.id,
@@ -171,16 +172,24 @@ export function compileBuild(
verifyRecord(program.closure, record);
invariant(!authored.has(record.id), "PROVIDED_RECORD_CONFLICT", `${record.id} conflicts with authored input`);
const previous = initialValues.get(record.id);
- invariant(
- previous === undefined || canonicalStringify(previous) === canonicalStringify(record),
- "PROVIDED_RECORD_CONFLICT",
- `${record.id} has conflicting Provided Values`,
- record.id,
- );
- initialValues.set(record.id, record);
+ if (previous === undefined) {
+ initialValues.set(record.id, record);
+ } else {
+ const { conformance: _previousConformance, ...previousFact } = previous;
+ const { conformance: _recordConformance, ...currentFact } = record;
+ invariant(
+ canonicalStringify(previousFact) === canonicalStringify(currentFact),
+ "PROVIDED_RECORD_CONFLICT",
+ `${record.id} has conflicting Provided Values`,
+ record.id,
+ );
+ // One materialized fact has one plan-wide conformance. If callers need the same bytes with
+ // independent path fidelity, the Run Graph must expose explicit identity projections.
+ initialValues.set(record.id, { ...previous, conformance: worst(previous.conformance, fidelity) });
+ }
resolved = { record: record.id, type: record.type };
} else {
- resolved = demandOperation(candidate.root.result.operation, candidate.fidelity);
+ resolved = demandOperation(candidate.root.result.operation, fidelity);
}
invariant(
sameType(resolved.type, output.type),
@@ -190,7 +199,7 @@ export function compileBuild(
);
resolvingOutputs.delete(id);
resolvedOutputs.set(id, resolved);
- selections.set(id, { output: id, candidate: candidate.id, record: resolved.record });
+ selections.set(id, { output: id, candidate: candidate.id, fidelity, record: resolved.record });
return resolved;
};
@@ -235,7 +244,7 @@ function validatePlanStructure(
request: BuildRequest,
plan: BuildPlan,
): void {
- invariant(plan.format === "svml.plan@1", "UNSUPPORTED_PLAN", "unsupported build plan format");
+ invariant(plan.format === "svml.plan@2", "UNSUPPORTED_PLAN", "unsupported build plan format");
invariant(plan.graph === graph.id, "PLAN_GRAPH_MISMATCH", "build plan belongs to another graph");
invariant(plan.request === request.digest, "PLAN_REQUEST_MISMATCH", "build plan belongs to another request");
const { id: _id, ...content } = plan;
diff --git a/packages/core/src/reducer.ts b/packages/core/src/reducer.ts
index 323e8fdd..e0cbd441 100644
--- a/packages/core/src/reducer.ts
+++ b/packages/core/src/reducer.ts
@@ -384,7 +384,7 @@ export function start(
const plan: BuildPlan = compileBuild(program, graph, request);
verifyInitialAffinities(graph, plan, program.records);
const state: BuildState = {
- format: "svml.build@1",
+ format: "svml.build@2",
id: digestOf({
closure: program.closure.digest,
semantic: program.semanticDigest,
diff --git a/packages/core/src/verify.ts b/packages/core/src/verify.ts
index 7782a5f7..5ac449d1 100644
--- a/packages/core/src/verify.ts
+++ b/packages/core/src/verify.ts
@@ -185,7 +185,7 @@ function verifyOutstanding(state: BuildState, command: CoreCommand): void {
}
export function verifyBuildState(state: BuildState): void {
- invariant(state.format === "svml.build@1", "UNSUPPORTED_BUILD", "unsupported build state format");
+ invariant(state.format === "svml.build@2", "UNSUPPORTED_BUILD", "unsupported build state format");
invariant(
state.status === "active" || state.status === "complete" || state.status === "failed",
"INVALID_BUILD_STATUS",
diff --git a/packages/core/test/demand.test.ts b/packages/core/test/demand.test.ts
index da2ff34d..9077375d 100644
--- a/packages/core/test/demand.test.ts
+++ b/packages/core/test/demand.test.ts
@@ -40,6 +40,7 @@ const types = {
b: { module: moduleRef, name: "B" },
c: { module: moduleRef, name: "C" },
d: { module: moduleRef, name: "D" },
+ product: { module: moduleRef, name: "Product" },
combined: { module: moduleRef, name: "Combined" },
} satisfies Record<string, TypeRef>;
@@ -55,6 +56,9 @@ const producers = {
a2: producer("a2"),
b1: producer("b1"),
b2: producer("b2"),
+ makeProduct: producer("make-product"),
+ projectC: producer("project-c"),
+ projectD: producer("project-d"),
c: producer("c"),
};
const seedanceCapability = { module: moduleRef, name: "seedance-media" } as const;
@@ -75,6 +79,16 @@ const manifest: ModuleManifest = {
{ name: types.duration.name, schema: { kind: "number", minimum: 0 } },
{ name: types.image.name, schema: { kind: "string", minLength: 1 } },
{ name: types.imageSet.name, schema: { kind: "array", items: { kind: "string" }, minItems: 1 } },
+ {
+ name: types.product.name,
+ schema: {
+ kind: "object",
+ fields: {
+ C: { schema: { kind: "string", minLength: 1 } },
+ D: { schema: { kind: "string", minLength: 1 } },
+ },
+ },
+ },
...[types.a, types.b, types.c, types.d, types.combined].map((type) => ({
name: type.name,
schema: { kind: "string" as const, minLength: 1 },
@@ -162,6 +176,27 @@ const manifest: ModuleManifest = {
needs: [],
implementation: implementation("b2"),
},
+ {
+ name: producers.makeProduct.name,
+ inputs: [{ name: "A", type: types.a }, { name: "B", type: types.b }],
+ outputs: [{ name: "product", type: types.product }],
+ needs: [],
+ implementation: implementation("make-product"),
+ },
+ {
+ name: producers.projectC.name,
+ inputs: [{ name: "product", type: types.product }],
+ outputs: [{ name: "C", type: types.c }],
+ needs: [],
+ implementation: implementation("project-c"),
+ },
+ {
+ name: producers.projectD.name,
+ inputs: [{ name: "product", type: types.product }],
+ outputs: [{ name: "D", type: types.d }],
+ needs: [],
+ implementation: implementation("project-d"),
+ },
{
name: producers.c.name,
inputs: [{ name: "C", type: types.c }, { name: "D", type: types.d }],
@@ -180,33 +215,29 @@ function output(
id: string,
type: TypeRef,
primary: string,
- candidates: readonly string[],
semanticInputs: readonly GraphValueRef[],
): LogicalOutput {
- return { id, type, primary, candidates, semanticInputs };
+ return { id, type, primary, semanticInputs };
}
function candidate(
id: string,
- outputId: string,
+ type: TypeRef,
operation: string,
- fidelity: "exact" | "substitute" = "exact",
): Candidate {
- return { id, output: outputId, root: { kind: "operation", result: operationRef(operation) }, fidelity };
+ return { id, type, root: { kind: "operation", result: operationRef(operation) } };
}
function providedCandidate(
id: string,
- outputId: string,
+ type: TypeRef,
record: string,
value: CanonicalValue,
- fidelity: "exact" | "substitute" = "exact",
): Candidate {
return {
id,
- output: outputId,
+ type,
root: { kind: "value", value: { id: record, value: { kind: "inline", value }, provenance: { test: id } } },
- fidelity,
};
}
@@ -251,11 +282,11 @@ function createImageGraph(program: LinkedProgram): CompiledGraph {
return sealCompiledGraph({
program: program.semanticDigest,
outputs: [
- output("image1", types.image, "p1", ["p1", "existing-image1"], [recordRef("head:root")]),
- output("image2", types.image, "p2", ["p2", "existing-image2"], [recordRef("head:root"), outputRef("image1")]),
- output("image3", types.image, "p3", ["p3", "existing-image3"], [recordRef("head:root"), outputRef("image1"), outputRef("image2")]),
- output("images", types.imageSet, "collect", ["collect"], [outputRef("image1"), outputRef("image2"), outputRef("image3")]),
- output("media", types.image, "seedance", ["seedance", "black", "existing-media"], [
+ output("image1", types.image, "p1", [recordRef("head:root")]),
+ output("image2", types.image, "p2", [recordRef("head:root"), outputRef("image1")]),
+ output("image3", types.image, "p3", [recordRef("head:root"), outputRef("image1"), outputRef("image2")]),
+ output("images", types.imageSet, "collect", [outputRef("image1"), outputRef("image2"), outputRef("image3")]),
+ output("media", types.image, "seedance", [
recordRef("head:root"),
recordRef("duration:root"),
outputRef("image1"),
@@ -263,16 +294,16 @@ function createImageGraph(program: LinkedProgram): CompiledGraph {
]),
],
candidates: [
- candidate("p1", "image1", "p1"),
- candidate("p2", "image2", "p2"),
- candidate("p3", "image3", "p3"),
- candidate("collect", "images", "collect"),
- candidate("seedance", "media", "seedance"),
- candidate("black", "media", "black", "substitute"),
- providedCandidate("existing-image1", "image1", "provided:image1", "I1"),
- providedCandidate("existing-image2", "image2", "provided:image2", "I2"),
- providedCandidate("existing-image3", "image3", "provided:image3", "I3"),
- providedCandidate("existing-media", "media", "provided:media", "EXISTING MEDIA"),
+ candidate("p1", types.image, "p1"),
+ candidate("p2", types.image, "p2"),
+ candidate("p3", types.image, "p3"),
+ candidate("collect", types.imageSet, "collect"),
+ candidate("seedance", types.image, "seedance"),
+ candidate("black", types.image, "black"),
+ providedCandidate("existing-image1", types.image, "provided:image1", "I1"),
+ providedCandidate("existing-image2", types.image, "provided:image2", "I2"),
+ providedCandidate("existing-image3", types.image, "provided:image3", "I3"),
+ providedCandidate("existing-media", types.image, "provided:media", "EXISTING MEDIA"),
],
operations: [
operation("p1", producers.p1, { head: recordRef("head:root") }, { kind: "output", name: "image", record: "image:1" }),
@@ -293,24 +324,24 @@ function createImageGraph(program: LinkedProgram): CompiledGraph {
function request(
graph: CompiledGraph,
targets: readonly string[],
- bindings: readonly CandidateBinding[] = [],
+ satisfactions: readonly CandidateBinding[] = [],
accepts: "exact" | "substitute" = "substitute",
): BuildRequest {
return sealBuildRequest({
graph: graph.id,
targets: targets.map((outputId) => ({ output: outputId, accepts })),
- bindings,
+ satisfactions,
});
}
-function fixture(targets: readonly string[], bindings: readonly CandidateBinding[] = []): BuildState {
+function fixture(targets: readonly string[], satisfactions: readonly CandidateBinding[] = []): BuildState {
const program = createProgram();
const graph = createImageGraph(program);
- return start(program, graph, request(graph, targets, bindings));
+ return start(program, graph, request(graph, targets, satisfactions));
}
function choose(outputId: string, candidateId: string): CandidateBinding {
- return { output: outputId, candidate: candidateId };
+ return { output: outputId, candidate: candidateId, fidelity: "substitute" };
}
function stepIds(state: BuildState): string[] {
@@ -389,7 +420,7 @@ test("Provided Values are checked against the Logical Output Contract", () => {
outputs: graph.outputs,
operations: graph.operations,
candidates: graph.candidates.map((item) => item.id === "existing-image1"
- ? providedCandidate("existing-image1", "image1", "provided:image1", 42)
+ ? providedCandidate("existing-image1", types.image, "provided:image1", 42)
: item),
});
assert.throws(() => start(program, invalid, request(invalid, ["image1"], [
@@ -414,22 +445,22 @@ function createCaseGGraph(program: LinkedProgram, roots: "value" | "operation"):
return sealCompiledGraph({
program: program.semanticDigest,
outputs: [
- output("a.A", types.a, a1Id, [a1Id], []),
- output("a.B", types.b, a2Id, [a2Id], []),
- output("b.C", types.c, "b1", ["b1"], [outputRef("a.A"), outputRef("a.B")]),
- output("b.D", types.d, "b2", ["b2"], [outputRef("a.A"), outputRef("a.B")]),
- output("c.result", types.combined, "c", ["c"], [outputRef("b.C"), outputRef("b.D")]),
+ output("a.A", types.a, a1Id, []),
+ output("a.B", types.b, a2Id, []),
+ output("b.C", types.c, "b1", [outputRef("a.A"), outputRef("a.B")]),
+ output("b.D", types.d, "b2", [outputRef("a.A"), outputRef("a.B")]),
+ output("c.result", types.combined, "c", [outputRef("b.C"), outputRef("b.D")]),
],
candidates: [
roots === "value"
- ? providedCandidate(a1Id, "a.A", "provided:A", "A")
- : candidate(a1Id, "a.A", "a1"),
+ ? providedCandidate(a1Id, types.a, "provided:A", "A")
+ : candidate(a1Id, types.a, "a1"),
roots === "value"
- ? providedCandidate(a2Id, "a.B", "provided:B", "B")
- : candidate(a2Id, "a.B", "a2"),
- candidate("b1", "b.C", "b1"),
- candidate("b2", "b.D", "b2"),
- candidate("c", "c.result", "c"),
+ ? providedCandidate(a2Id, types.b, "provided:B", "B")
+ : candidate(a2Id, types.b, "a2"),
+ candidate("b1", types.c, "b1"),
+ candidate("b2", types.d, "b2"),
+ candidate("c", types.combined, "c"),
],
operations: [
operation("a1", producers.a1, {}, { kind: "output", name: "value", record: "operation:A" }),
@@ -475,14 +506,15 @@ function createOperationIdentityGraph(
return sealCompiledGraph({
program: program.semanticDigest,
outputs: [
- output("left", types.image, "left-candidate", ["left-candidate"], [recordRef("head:root")]),
- output("right", types.image, "right-candidate", ["right-candidate"], [recordRef("head:root")]),
+ output("left", types.image, "left-candidate", [recordRef("head:root")]),
+ output("right", types.image, "right-candidate", [recordRef("head:root")]),
],
candidates: [
- candidate("left-candidate", "left", "left-operation"),
+ candidate("left-candidate", types.image, "left-operation"),
+ candidate("shared-candidate", types.image, "left-operation"),
candidate(
"right-candidate",
- "right",
+ types.image,
mode === "shared" ? "left-operation" : "right-operation",
),
],
@@ -516,6 +548,20 @@ test("two Candidates that name one OperationId demand exactly one execution", ()
);
});
+test("one independent Candidate may explicitly satisfy multiple compatible Logical Outputs", () => {
+ const program = createProgram();
+ const graph = createOperationIdentityGraph(program, "shared");
+ const state = start(program, graph, request(graph, ["left", "right"], [
+ { output: "left", candidate: "shared-candidate", fidelity: "exact" },
+ { output: "right", candidate: "shared-candidate", fidelity: "exact" },
+ ]));
+ assert.deepEqual(stepIds(state), ["left-operation"]);
+ assert.deepEqual(
+ state.plan.selections.map((selection) => [selection.output, selection.candidate]),
+ [["left", "shared-candidate"], ["right", "shared-candidate"]],
+ );
+});
+
test("different OperationIds are never content-deduplicated", () => {
const program = createProgram();
const graph = createOperationIdentityGraph(program, "distinct");
@@ -528,6 +574,124 @@ test("different OperationIds are never content-deduplicated", () => {
);
});
+function createProductReplacementGraph(
+ program: LinkedProgram,
+ alternate: "shared" | "distinct",
+): CompiledGraph {
+ const productOperation = (
+ id: string,
+ record: string,
+ ): OperationNode => operation(
+ id,
+ producers.makeProduct,
+ { A: outputRef("a.A"), B: outputRef("a.B") },
+ { kind: "output", name: "product", record },
+ );
+ const projection = (
+ id: string,
+ producerRef: ProducerRef,
+ product: string,
+ name: "C" | "D",
+ record: string,
+ ): OperationNode => operation(
+ id,
+ producerRef,
+ { product: operationRef(product) },
+ { kind: "output", name, record },
+ );
+ const altCProduct = "b.alt.product.c";
+ const altDProduct = alternate === "shared" ? altCProduct : "b.alt.product.d";
+ return sealCompiledGraph({
+ program: program.semanticDigest,
+ outputs: [
+ output("a.A", types.a, "a.A.primary", []),
+ output("a.B", types.b, "a.B.primary", []),
+ output("b.C", types.c, "b.C.primary", [outputRef("a.A"), outputRef("a.B")]),
+ output("b.D", types.d, "b.D.primary", [outputRef("a.A"), outputRef("a.B")]),
+ output("c.result", types.combined, "c.primary", [outputRef("b.C"), outputRef("b.D")]),
+ ],
+ candidates: [
+ candidate("a.A.primary", types.a, "a1"),
+ candidate("a.B.primary", types.b, "a2"),
+ candidate("b.C.primary", types.c, "b.default.C"),
+ candidate("b.D.primary", types.d, "b.default.D"),
+ candidate("b.C.alternate", types.c, "b.alt.C"),
+ candidate("b.D.alternate", types.d, "b.alt.D"),
+ candidate("c.primary", types.combined, "c"),
+ ],
+ operations: [
+ operation("a1", producers.a1, {}, { kind: "output", name: "value", record: "product:A" }),
+ operation("a2", producers.a2, {}, { kind: "output", name: "value", record: "product:B" }),
+ productOperation("b.default.product", "product:default"),
+ projection("b.default.C", producers.projectC, "b.default.product", "C", "product:default:C"),
+ projection("b.default.D", producers.projectD, "b.default.product", "D", "product:default:D"),
+ productOperation(altCProduct, "product:alternate:C"),
+ ...(alternate === "distinct" ? [productOperation(altDProduct, "product:alternate:D")] : []),
+ projection("b.alt.C", producers.projectC, altCProduct, "C", "product:alternate:C:projection"),
+ projection("b.alt.D", producers.projectD, altDProduct, "D", "product:alternate:D:projection"),
+ operation("c", producers.c, { C: outputRef("b.C"), D: outputRef("b.D") }, {
+ kind: "output",
+ name: "combined",
+ record: "product:combined",
+ }),
+ ],
+ });
+}
+
+const substitute = (outputId: string, candidateId: string): CandidateBinding => ({
+ output: outputId,
+ candidate: candidateId,
+ fidelity: "substitute",
+});
+
+test("one Run-Graph instance satisfies two Logical Outputs through one shared Product", () => {
+ const program = createProgram();
+ const graph = createProductReplacementGraph(program, "shared");
+ const state = start(program, graph, request(graph, ["c.result"], [
+ substitute("b.C", "b.C.alternate"),
+ substitute("b.D", "b.D.alternate"),
+ ]));
+ assert.deepEqual(stepIds(state), ["a1", "a2", "b.alt.C", "b.alt.D", "b.alt.product.c", "c"]);
+ assert.equal(state.plan.steps.filter((step) => step.producer.name === producers.makeProduct.name).length, 1);
+ assert.equal(state.plan.steps.some((step) => step.id.startsWith("b.default")), false);
+});
+
+test("two explicit Run-Graph instances may separately satisfy the two outputs", () => {
+ const program = createProgram();
+ const graph = createProductReplacementGraph(program, "distinct");
+ const state = start(program, graph, request(graph, ["c.result"], [
+ substitute("b.C", "b.C.alternate"),
+ substitute("b.D", "b.D.alternate"),
+ ]));
+ assert.deepEqual(stepIds(state), [
+ "a1", "a2", "b.alt.C", "b.alt.D", "b.alt.product.c", "b.alt.product.d", "c",
+ ]);
+ assert.equal(state.plan.steps.filter((step) => step.producer.name === producers.makeProduct.name).length, 2);
+ assert.equal(state.plan.steps.some((step) => step.id.startsWith("b.default")), false);
+});
+
+test("partial satisfaction keeps only the demanded projection of the default Product", () => {
+ const program = createProgram();
+ const graph = createProductReplacementGraph(program, "shared");
+ const state = start(program, graph, request(graph, ["c.result"], [
+ substitute("b.C", "b.C.alternate"),
+ ]));
+ assert.deepEqual(stepIds(state), [
+ "a1", "a2", "b.alt.C", "b.alt.product.c", "b.default.D", "b.default.product", "c",
+ ]);
+ assert.equal(state.plan.steps.some((step) => step.id === "b.default.C"), false);
+});
+
+test("an unbound sibling output cannot keep an unreachable default Product alive", () => {
+ const program = createProgram();
+ const graph = createProductReplacementGraph(program, "shared");
+ const state = start(program, graph, request(graph, ["b.C"], [
+ substitute("b.C", "b.C.alternate"),
+ ]));
+ assert.deepEqual(stepIds(state), ["a1", "a2", "b.alt.C", "b.alt.product.c"]);
+ assert.equal(state.plan.steps.some((step) => step.id.startsWith("b.default")), false);
+});
+
test("an exact Target rejects a selected substitute Candidate before execution", () => {
const program = createProgram();
const graph = createImageGraph(program);
diff --git a/packages/core/test/greeting-fixture.ts b/packages/core/test/greeting-fixture.ts
index 3391314c..793227b9 100644
--- a/packages/core/test/greeting-fixture.ts
+++ b/packages/core/test/greeting-fixture.ts
@@ -138,29 +138,26 @@ export function greetingGraph(program: LinkedProgram): CompiledGraph {
id: "prompt",
type: types.prompt,
primary: "make-prompt",
- candidates: ["make-prompt"],
semanticInputs: [{ kind: "record", id: "intent:root" }],
},
{
id: "generated",
type: types.generated,
primary: "request-text",
- candidates: ["request-text", "placeholder-text"],
semanticInputs: [{ kind: "logical-output", id: "prompt" }],
},
{
id: "document",
type: types.document,
primary: "assemble",
- candidates: ["assemble"],
semanticInputs: [{ kind: "logical-output", id: "generated" }],
},
],
candidates: [
- { id: "make-prompt", output: "prompt", root: { kind: "operation", result: { kind: "operation-result", operation: "make-prompt" } }, fidelity: "exact" },
- { id: "request-text", output: "generated", root: { kind: "operation", result: { kind: "operation-result", operation: "request-text" } }, fidelity: "exact" },
- { id: "placeholder-text", output: "generated", root: { kind: "operation", result: { kind: "operation-result", operation: "placeholder-text" } }, fidelity: "substitute" },
- { id: "assemble", output: "document", root: { kind: "operation", result: { kind: "operation-result", operation: "assemble" } }, fidelity: "exact" },
+ { id: "make-prompt", type: types.prompt, root: { kind: "operation", result: { kind: "operation-result", operation: "make-prompt" } } },
+ { id: "request-text", type: types.generated, root: { kind: "operation", result: { kind: "operation-result", operation: "request-text" } } },
+ { id: "placeholder-text", type: types.generated, root: { kind: "operation", result: { kind: "operation-result", operation: "placeholder-text" } } },
+ { id: "assemble", type: types.document, root: { kind: "operation", result: { kind: "operation-result", operation: "assemble" } } },
],
operations: [
{
@@ -225,10 +222,11 @@ export function createGreetingBuild(options?: {
output: "document",
accepts: options?.goalAccepts ?? "exact",
}],
- bindings: options?.generationRealization === "placeholder"
+ satisfactions: options?.generationRealization === "placeholder"
? [{
output: "generated",
candidate: "placeholder-text",
+ fidelity: "substitute",
}]
: [],
});
diff --git a/packages/driver-node/test/scheduler.test.ts b/packages/driver-node/test/scheduler.test.ts
index 2e2c4761..f33b93e9 100644
--- a/packages/driver-node/test/scheduler.test.ts
+++ b/packages/driver-node/test/scheduler.test.ts
@@ -71,42 +71,36 @@ function createParallelGreetingBuild() {
id: "prompt",
type: types.prompt,
primary: "make-prompt",
- candidates: ["make-prompt"],
semanticInputs: [{ kind: "record", id: "intent:root" }],
},
{
id: "generated-a",
type: types.generated,
primary: "generate-a",
- candidates: ["generate-a"],
semanticInputs: [{ kind: "logical-output", id: "prompt" }],
},
{
id: "generated-b",
type: types.generated,
primary: "generate-b",
- candidates: ["generate-b"],
semanticInputs: [{ kind: "logical-output", id: "prompt" }],
},
],
candidates: [
{
id: "make-prompt",
- output: "prompt",
+ type: types.prompt,
root: { kind: "operation", result: { kind: "operation-result", operation: "make-prompt" } },
- fidelity: "exact",
},
{
id: "generate-a",
- output: "generated-a",
+ type: types.generated,
root: { kind: "operation", result: { kind: "operation-result", operation: "generate-a" } },
- fidelity: "exact",
},
{
id: "generate-b",
- output: "generated-b",
+ type: types.generated,
root: { kind: "operation", result: { kind: "operation-result", operation: "generate-b" } },
- fidelity: "exact",
},
],
operations: [
@@ -148,7 +142,7 @@ function createParallelGreetingBuild() {
{ output: "generated-a", accepts: "exact" },
{ output: "generated-b", accepts: "exact" },
],
- bindings: [],
+ satisfactions: [],
}));
}
diff --git a/packages/driver-node/test/validation.test.ts b/packages/driver-node/test/validation.test.ts
index 656e8fbe..91d00b2f 100644
--- a/packages/driver-node/test/validation.test.ts
+++ b/packages/driver-node/test/validation.test.ts
@@ -181,29 +181,25 @@ function outputGraph(linked: LinkedProgram): CompiledGraph {
id: "measurement",
type: measurementType,
primary: "measure",
- candidates: ["measure"],
semanticInputs: [],
},
{
id: "report",
type: reportType,
primary: "report",
- candidates: ["report"],
semanticInputs: [{ kind: "logical-output", id: "measurement" }],
},
],
candidates: [
{
id: "measure",
- output: "measurement",
+ type: measurementType,
root: { kind: "operation", result: { kind: "operation-result", operation: "measure" } },
- fidelity: "exact",
},
{
id: "report",
- output: "report",
+ type: reportType,
root: { kind: "operation", result: { kind: "operation-result", operation: "report" } },
- fidelity: "exact",
},
],
operations: [
@@ -227,7 +223,7 @@ function outputBuild(linked: LinkedProgram, graph = outputGraph(linked)) {
return start(linked, graph, sealBuildRequest({
graph: graph.id,
targets: [{ output: "report", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
}
@@ -306,14 +302,12 @@ function providerGraph(linked: LinkedProgram): CompiledGraph {
id: "measurement",
type: measurementType,
primary: "request",
- candidates: ["request"],
semanticInputs: [],
}],
candidates: [{
id: "request",
- output: "measurement",
+ type: measurementType,
root: { kind: "operation", result: { kind: "operation-result", operation: "request" } },
- fidelity: "exact",
}],
operations: [{
id: "request",
@@ -356,7 +350,7 @@ async function providerBuild(measured: number) {
sealBuildRequest({
graph: graph.id,
targets: [{ output: "measurement", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}),
));
}
diff --git a/packages/elaborator/README.md b/packages/elaborator/README.md
index 406d3ba2..3c26cd87 100644
--- a/packages/elaborator/README.md
+++ b/packages/elaborator/README.md
@@ -9,7 +9,7 @@ phases:
1. lock every referenced Fragment and predeclare every component export;
2. resolve references, reject missing values, type mismatches and cycles, hygienically instantiate
- Fragments, then emit one ordinary `svml.graph@1` for Core.
+ Fragments, then emit one ordinary `svml.graph@2` for Core.
Because all exports are collected before any input is resolved, declaration order has no meaning
and a component may reference a later component. The linker itself does not parse `.svml`, execute
@@ -54,8 +54,14 @@ Envelopes and affinity sources.
Expansion assigns hygienic identities from `fragment digest + author instance id + local id`.
Multiple exports of one instance therefore share internal Operations, while two explicit instances
-are never content-deduplicated. The result is ordinary `LogicalOutput`, `Candidate` and
-`OperationNode` data that Core validates again.
+remain two nodes even when their content is identical. Author exports become Logical Outputs with
+Primary Candidates; Run exports become independent typed Candidates plus explicit Satisfaction
+edges. The result is ordinary graph data that Core validates again before freezing a BuildPlan.
+
+`exportRunFragment()` is the canonical Run-Graph boundary: it exports independent Candidates and
+does not name an Author Logical Output. `bindCandidateFragment()` remains compatibility sugar that
+additionally creates Satisfaction edges; new Run frontends should keep graph declaration and
+`output -> candidate + fidelity` selection separate.
`@svml/elaborator` is not a public `@svml/author` subsystem. It is a reusable graph-construction
library. A domain normally adds its own contract and component packages; Text remains only one
diff --git a/packages/elaborator/src/fragment.ts b/packages/elaborator/src/fragment.ts
index dae7235b..3a25b9be 100644
--- a/packages/elaborator/src/fragment.ts
+++ b/packages/elaborator/src/fragment.ts
@@ -7,6 +7,7 @@ import {
import type {
AffinityConstraint,
Candidate,
+ Satisfaction,
CandidateRoot,
CompiledGraph,
Conformance,
@@ -100,6 +101,20 @@ export type FragmentContribution = {
readonly outputs: readonly LogicalOutput[];
readonly candidates: readonly Candidate[];
readonly operations: readonly OperationNode[];
+ /** Explicit Run-Graph satisfactions; Author contributions leave this absent. */
+ readonly satisfactions?: readonly Satisfaction[];
+};
+
+export type RunFragmentExport = {
+ readonly name: string;
+ readonly candidate: string;
+ readonly type: TypeRef;
+ /** Package default for authoring a Satisfaction; not intrinsic Candidate identity. */
+ readonly suggestedFidelity: Conformance;
+};
+
+export type RunFragmentContribution = FragmentContribution & {
+ readonly exports: readonly RunFragmentExport[];
};
export class FragmentError extends Error {
@@ -503,10 +518,9 @@ function bindExports(
const output = bindings[item.name] as string;
assert(output.length > 0, "EMPTY_LOGICAL_OUTPUT_ID", `${instance.instance}.${item.name} output is empty`);
return {
- id: hygienicId("candidate", instance.fragment, instance.instance, `${item.name}\u0000${output}`),
- output,
+ id: hygienicId("candidate", instance.fragment, instance.instance, item.name),
+ type: item.type,
root: item.root,
- fidelity: item.fidelity,
};
});
const outputs: LogicalOutput[] = requireAll
@@ -514,7 +528,6 @@ function bindExports(
id: bindings[item.name] as string,
type: item.type,
primary: candidates[index]!.id,
- candidates: [candidates[index]!.id],
semanticInputs: item.semanticInputs,
...(item.affinity === undefined ? {} : { affinity: item.affinity }),
}))
@@ -524,6 +537,51 @@ function bindExports(
outputs,
candidates,
operations: instance.operations.filter((operation) => reachable.has(operation.id)),
+ ...(requireAll
+ ? {}
+ : {
+ satisfactions: selected.map((item, index) => ({
+ output: bindings[item.name] as string,
+ candidate: candidates[index]!.id,
+ fidelity: item.fidelity,
+ })),
+ }),
+ };
+}
+
+/**
+ * Instantiate a Run-Graph Fragment without deciding which Author Logical Outputs it will satisfy.
+ * Multiple exports share the instance's internal Operations; separate calls always create separate
+ * instances because identity comes from the already elaborated `instance.instance` path.
+ */
+export function exportRunFragment(
+ instance: ElaboratedFragment,
+ names: readonly string[] = instance.exports.map((item) => item.name),
+): RunFragmentContribution {
+ assert(names.length > 0, "EMPTY_FRAGMENT_BINDING", `${instance.instance} exports no Run values`);
+ assert(new Set(names).size === names.length, "DUPLICATE_FRAGMENT_EXPORT", `${instance.instance} repeats a Run export`);
+ const available = exportMap(instance);
+ const selected = names.map((name) => {
+ const item = available.get(name);
+ assert(item !== undefined, "UNKNOWN_FRAGMENT_EXPORT", `${instance.instance} has no export ${name}`);
+ return item;
+ });
+ const candidates: Candidate[] = selected.map((item) => ({
+ id: hygienicId("candidate", instance.fragment, instance.instance, item.name),
+ type: item.type,
+ root: item.root,
+ }));
+ const reachable = reachableOperationIds(instance, selected);
+ return {
+ outputs: [],
+ candidates,
+ operations: instance.operations.filter((operation) => reachable.has(operation.id)),
+ exports: selected.map((item, index) => ({
+ name: item.name,
+ candidate: candidates[index]!.id,
+ type: item.type,
+ suggestedFidelity: item.fidelity,
+ })),
};
}
@@ -535,12 +593,25 @@ export function bindAuthorFragment(
return bindExports(instance, outputs, true);
}
-/** Bind selected Fragment exports as Candidate attachments for existing Logical Outputs. */
+/**
+ * Export selected Run-Graph values and their explicit Satisfaction edges.
+ * The Candidate identity is independent of the Logical Output named by `outputs`.
+ */
export function bindCandidateFragment(
instance: ElaboratedFragment,
outputs: Readonly<Record<string, string>>,
): FragmentContribution {
- return bindExports(instance, outputs, false);
+ const contribution = exportRunFragment(instance, Object.keys(outputs));
+ return {
+ outputs: [],
+ candidates: contribution.candidates,
+ operations: contribution.operations,
+ satisfactions: contribution.exports.map((item) => ({
+ output: outputs[item.name] as string,
+ candidate: item.candidate,
+ fidelity: item.suggestedFidelity,
+ })),
+ };
}
/** Merge already elaborated contributions; final Graph validation remains Core's authority. */
diff --git a/packages/elaborator/src/index.ts b/packages/elaborator/src/index.ts
index f22248cb..f1dae68e 100644
--- a/packages/elaborator/src/index.ts
+++ b/packages/elaborator/src/index.ts
@@ -47,6 +47,7 @@ export {
bindAuthorFragment,
bindCandidateFragment,
elaborateGraphFragment,
+ exportRunFragment,
FragmentError,
mergeFragmentContributions,
sameFragmentInstance,
@@ -65,5 +66,7 @@ export type {
FragmentOperationRef,
FragmentOperationResult,
FragmentValueRef,
+ RunFragmentContribution,
+ RunFragmentExport,
GraphFragment,
} from "./fragment.js";
diff --git a/packages/elaborator/test/author.test.ts b/packages/elaborator/test/author.test.ts
index 0d8530be..15e4afd3 100644
--- a/packages/elaborator/test/author.test.ts
+++ b/packages/elaborator/test/author.test.ts
@@ -201,7 +201,7 @@ test("Author linking resolves forward component references without Text or video
const request = sealBuildRequest({
graph: elaborated.graph.id,
targets: [{ output: "report:final", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
});
const state = start(linked, elaborated.graph, request);
assert.deepEqual(
diff --git a/packages/elaborator/test/fragment.test.ts b/packages/elaborator/test/fragment.test.ts
index 1f557a0e..f57255c3 100644
--- a/packages/elaborator/test/fragment.test.ts
+++ b/packages/elaborator/test/fragment.test.ts
@@ -198,7 +198,7 @@ test("one FragmentInstance shares its generation Operation across all exports",
{ output: "opening.audio", accepts: "exact" },
{ output: "opening.visual", accepts: "exact" },
],
- bindings: [],
+ satisfactions: [],
});
const state = start(linked, compiled, request);
assert.equal(
@@ -248,7 +248,7 @@ test("the same Fragment instance is deterministic while distinct instances never
{ output: "opening.audio", accepts: "exact" },
{ output: "closing.audio", accepts: "exact" },
],
- bindings: [],
+ satisfactions: [],
}));
assert.equal(
state.plan.steps.filter((step) => step.producer.name === generateProducer.name).length,
diff --git a/packages/film/test/film.test.ts b/packages/film/test/film.test.ts
index 5a92b927..631e7a6e 100644
--- a/packages/film/test/film.test.ts
+++ b/packages/film/test/film.test.ts
@@ -197,7 +197,7 @@ function build(target: string) {
return start(linked, graph, sealBuildRequest({
graph: graph.id,
targets: [{ output: target, accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
}
diff --git a/packages/film/test/surface.test.ts b/packages/film/test/surface.test.ts
index 2a9394d5..ef808ef6 100644
--- a/packages/film/test/surface.test.ts
+++ b/packages/film/test/surface.test.ts
@@ -170,7 +170,7 @@ test("the official Film Surface validates SVS and lowers dynamic peer Tracks", a
const build = start(compiled.program, compiled.elaboration.graph, sealBuildRequest({
graph: compiled.elaboration.graph.id,
targets: [{ output: target.ref.kind === "logical-output" ? target.ref.id : "", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
assert.deepEqual(build.plan.steps.map((step) => step.producer.name).sort(), [
filmProducers.createTrackSet.name,
diff --git a/packages/hyperframes-render/test/render.test.ts b/packages/hyperframes-render/test/render.test.ts
index e6229861..4bb6f394 100644
--- a/packages/hyperframes-render/test/render.test.ts
+++ b/packages/hyperframes-render/test/render.test.ts
@@ -136,7 +136,7 @@ function build() {
return start(linked, graph, sealBuildRequest({
graph: graph.id,
targets: [{ output: "final.video", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
}
@@ -416,7 +416,7 @@ test("the official render Surface lowers real author source to the same BuildPla
const state = start(compiled.program, compiled.elaboration.graph, sealBuildRequest({
graph: compiled.elaboration.graph.id,
targets: [{ output: target.ref.kind === "logical-output" ? target.ref.id : "", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
assert.deepEqual(state.plan.steps.map((step) => step.producer.name).sort(), [
hyperframesProducers.compile.name,
diff --git a/packages/protocol/src/build.ts b/packages/protocol/src/build.ts
index 5234c2c0..f46a3218 100644
--- a/packages/protocol/src/build.ts
+++ b/packages/protocol/src/build.ts
@@ -171,7 +171,6 @@ export type LogicalOutput = {
readonly id: LogicalOutputId;
readonly type: TypeRef;
readonly primary: CandidateId;
- readonly candidates: readonly CandidateId[];
/** Author-visible facts that a Candidate may transitively depend upon. */
readonly semanticInputs: readonly GraphValueRef[];
readonly affinity?: readonly AffinityConstraint[];
@@ -211,14 +210,13 @@ export type CandidateRoot =
export type Candidate = {
readonly id: CandidateId;
- readonly output: LogicalOutputId;
+ /** Type of the independent value exported by the Author or Run Graph. */
+ readonly type: TypeRef;
readonly root: CandidateRoot;
- /** Fidelity to the Logical Output promise, independent of Provider fulfillment. */
- readonly fidelity: Conformance;
};
export type CompiledGraph = {
- readonly format: "svml.graph@1";
+ readonly format: "svml.graph@2";
readonly id: Digest;
readonly program: Digest;
/** Digest of the author graph before external Candidate attachment. */
@@ -235,24 +233,30 @@ export type BuildTarget = {
readonly accepts: NeedAcceptance;
};
-export type CandidateBinding = {
+export type Satisfaction = {
readonly output: LogicalOutputId;
readonly candidate: CandidateId;
+ /** Fidelity of this Candidate to this Logical Output promise. */
+ readonly fidelity: Conformance;
};
+/** @deprecated Use Satisfaction. */
+export type CandidateBinding = Satisfaction;
+
export type BuildRequest = {
- readonly format: "svml.build-request@1";
+ readonly format: "svml.build-request@2";
readonly graph: Digest;
/** Exact trusted implementation-package closure selected outside author source. */
readonly implementationClosure?: Digest;
readonly targets: readonly BuildTarget[];
- readonly bindings: readonly CandidateBinding[];
+ readonly satisfactions: readonly Satisfaction[];
readonly digest: Digest;
};
export type BuildSelection = {
readonly output: LogicalOutputId;
readonly candidate: CandidateId;
+ readonly fidelity: Conformance;
readonly record: RecordId;
};
@@ -272,7 +276,7 @@ export type BuildGoal = {
};
export type BuildPlan = {
- readonly format: "svml.plan@1";
+ readonly format: "svml.plan@2";
readonly id: Digest;
readonly graph: Digest;
readonly request: Digest;
@@ -361,7 +365,7 @@ export type BuildDiagnostic = {
};
export type BuildState = {
- readonly format: "svml.build@1";
+ readonly format: "svml.build@2";
readonly id: Digest;
readonly program: LinkedProgram;
readonly graph: CompiledGraph;
diff --git a/packages/provider-kie/test/live-smoke.ts b/packages/provider-kie/test/live-smoke.ts
index b7fcfe3d..89b3c5ad 100644
--- a/packages/provider-kie/test/live-smoke.ts
+++ b/packages/provider-kie/test/live-smoke.ts
@@ -368,14 +368,12 @@ async function createBuild(item: SmokeCase): Promise<ReturnType<typeof start>> {
id: item.ids.output,
type: item.endpoint.returns,
primary: item.ids.candidate,
- candidates: [item.ids.candidate],
semanticInputs: [{ kind: "record", id: authored.id }],
}],
candidates: [{
id: item.ids.candidate,
- output: item.ids.output,
+ type: item.endpoint.returns,
root: { kind: "operation", result: { kind: "operation-result", operation: item.ids.operation } },
- fidelity: "exact",
}],
operations: [{
id: item.ids.operation,
@@ -393,7 +391,7 @@ async function createBuild(item: SmokeCase): Promise<ReturnType<typeof start>> {
return start(program, graph, sealBuildRequest({
graph: graph.id,
targets: [{ output: item.ids.output, accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
}
diff --git a/packages/realization/README.md b/packages/realization/README.md
index 1b225912..cac40aae 100644
--- a/packages/realization/README.md
+++ b/packages/realization/README.md
@@ -1,25 +1,28 @@
# `@svml/realization`
-Content-addressed Candidate attachment outside SVML Core.
+Content-addressed Run Graph assembly outside SVML Core.
-A `svml.realization-overlay@1` locks the exact author Graph and contributes Candidates plus any
-already elaborated Operations. `resolveRealization()` merges one or more Overlays deterministically,
-retains the author source digest, records a separate Realization Closure digest, and produces the
-final `CompiledGraph` consumed by Build Compiler.
+A `svml.realization-overlay@2` locks the exact Author Graph and contributes independent typed
+Candidates plus any already elaborated Operations. It does not attach those Candidates to, or
+rewrite, Author Logical Outputs. `resolveRealization()` merges one or more Run Graph overlays
+deterministically, retains the author source digest, records a separate Realization Closure digest,
+and produces the graph universe consumed by Build Compiler.
-An attached Candidate is inert. It enters a finite BuildPlan only when a `BuildRequest` explicitly
-selects it and a Target reaches its Logical Output. Product UI actions such as “Pin” create or locate
-an Existing-Value Candidate and then write that ordinary selection; they do not mutate Core state or
-require a database.
+A Candidate is inert. It enters a finite BuildPlan only when a `BuildRequest` establishes an
+explicit Satisfaction from a demanded Logical Output to that Candidate. The binding owns fidelity;
+the Candidate owns only its Type and value/operation root. Product UI actions such as “Pin” create
+or locate an Existing-Value Candidate and then write an ordinary substitute Satisfaction; they do
+not mutate Core state or require a database.
-`createHistoricalCandidate()` is a Host convenience for this common case. It verifies the complete
+`createBuildRecordCandidate()` is a Host convenience for this common case. It verifies the complete
prior `BuildState` only to extract a trusted typed Record, its type-validation receipt and optional
-provenance. It then reattaches that value to the current Logical Output as an ordinary zero-input
-`substitute` Candidate. The previous author Graph, prompt, semantic inputs and affinity are not
+provenance. It returns an independent zero-input Candidate; the caller may use a substitute
+Satisfaction to map it to any compatible Logical Output. The previous author Graph, prompt, semantic inputs and affinity are not
compatibility evidence and are not compared. No historical Operation, Command or outstanding work
is copied into the new Build.
The same model covers an uploaded video, a fixed black clip and any other already materialized
-value. Core checks the current output Type and value structure. A `substitute` Candidate need not
-prove the current output's author affinity; the BuildRequest must explicitly select it and the
+value. Core checks the Candidate Type/value on graph admission and checks it again against the
+selected output. A `substitute` Satisfaction need not prove the current output's author affinity;
+the BuildRequest must explicitly declare it and the
Target must explicitly accept substitute fidelity.
diff --git a/packages/realization/src/index.ts b/packages/realization/src/index.ts
index 3621e3e3..5d1dbab0 100644
--- a/packages/realization/src/index.ts
+++ b/packages/realization/src/index.ts
@@ -1,16 +1,20 @@
export {
+ createBuildRecordCandidate,
createHistoricalCandidate,
createProvidedCandidate,
RealizationError,
resolveRealization,
sealRealizationOverlay,
+ sealRunGraph,
verifyRealizationOverlay,
verifyResolvedRealization,
} from "./overlay.js";
export type {
+ BuildRecordCandidateInput,
HistoricalCandidateInput,
ProvidedCandidateInput,
RealizationClosure,
RealizationOverlay,
+ RunGraph,
ResolvedRealization,
} from "./overlay.js";
diff --git a/packages/realization/src/overlay.ts b/packages/realization/src/overlay.ts
index 73a4295d..902c0d78 100644
--- a/packages/realization/src/overlay.ts
+++ b/packages/realization/src/overlay.ts
@@ -3,7 +3,6 @@ import {
digestOf,
EMPTY_REALIZATION_DIGEST,
isDigest,
- resolveLogicalOutput,
sealCompiledGraph,
verifyBuildState,
verifyCompiledGraph,
@@ -13,25 +12,28 @@ import type {
Candidate,
CanonicalValue,
CompiledGraph,
- Conformance,
Digest,
LinkedProgram,
OperationNode,
StoredValue,
TypeValidationReceipt,
+ TypeRef,
} from "@svml/protocol";
export type RealizationOverlay = {
- readonly format: "svml.realization-overlay@1";
+ readonly format: "svml.realization-overlay@2";
readonly id: Digest;
- /** Exact author graph to which these Candidates may be attached. */
+ /** Exact Author Graph whose Logical Outputs may be referenced by this Run Graph. */
readonly sourceGraph: Digest;
readonly candidates: readonly Candidate[];
readonly operations: readonly OperationNode[];
};
+/** Canonical name for the external typed graph. */
+export type RunGraph = RealizationOverlay;
+
export type RealizationClosure = {
- readonly format: "svml.realization-closure@1";
+ readonly format: "svml.realization-closure@2";
readonly id: Digest;
readonly sourceGraph: Digest;
readonly overlays: readonly Digest[];
@@ -43,25 +45,23 @@ export type ResolvedRealization = {
};
export type ProvidedCandidateInput = {
- readonly output: string;
+ readonly type: TypeRef;
readonly value: StoredValue;
- readonly fidelity: Conformance;
readonly record?: string;
readonly provenance?: CanonicalValue;
readonly validation?: TypeValidationReceipt;
};
-export type HistoricalCandidateInput = {
- /** Current author graph before any external Realization Overlay. */
- readonly source: CompiledGraph;
+export type BuildRecordCandidateInput = {
/** A previously verified BuildState used only as a source of one typed value. */
readonly build: BuildState;
- /** Current Logical Output to which the value will be attached. */
- readonly output: string;
- /** Historical Logical Output to read; defaults to `output` only as a Host convenience. */
- readonly sourceOutput?: string;
+ /** Historical Logical Output whose selected Record becomes an independent Candidate. */
+ readonly sourceOutput: string;
};
+/** @deprecated Use BuildRecordCandidateInput. */
+export type HistoricalCandidateInput = BuildRecordCandidateInput;
+
export class RealizationError extends Error {
readonly code: string;
readonly subject: string | undefined;
@@ -80,7 +80,7 @@ function assert(condition: unknown, code: string, message: string, subject?: str
function overlayContent(overlay: RealizationOverlay): Omit<RealizationOverlay, "id"> {
return {
- format: "svml.realization-overlay@1",
+ format: "svml.realization-overlay@2",
sourceGraph: overlay.sourceGraph,
candidates: [...overlay.candidates].sort((left, right) => left.id.localeCompare(right.id)),
operations: [...overlay.operations].sort((left, right) => left.id.localeCompare(right.id)),
@@ -91,7 +91,7 @@ export function sealRealizationOverlay(
overlay: Omit<RealizationOverlay, "format" | "id">,
): RealizationOverlay {
const draft = {
- format: "svml.realization-overlay@1" as const,
+ format: "svml.realization-overlay@2" as const,
id: digestOf("unsealed-realization-overlay"),
...overlay,
};
@@ -100,28 +100,24 @@ export function sealRealizationOverlay(
return { ...content, id: digestOf(content) };
}
+/** Canonical Run-Graph name; retained alongside the Overlay API name. */
+export const sealRunGraph = sealRealizationOverlay;
+
export function createProvidedCandidate(input: ProvidedCandidateInput): Candidate {
- assert(input.output.length > 0, "EMPTY_LOGICAL_OUTPUT_ID", "Provided Candidate output is empty");
- assert(
- input.fidelity === "exact" || input.fidelity === "substitute",
- "INVALID_CONFORMANCE",
- "Provided Candidate fidelity is invalid",
- );
const value = input.value.kind === "inline"
? { kind: "inline" as const, value: canonicalize(input.value.value) }
: { ...input.value };
const identity = {
kind: "provided-candidate@1",
- output: input.output,
+ type: input.type,
value,
- fidelity: input.fidelity,
...(input.provenance === undefined ? {} : { provenance: canonicalize(input.provenance) }),
...(input.validation === undefined ? {} : { validation: input.validation }),
};
const suffix = digestOf(identity).slice("sha256:".length);
return {
id: `candidate:${suffix}`,
- output: input.output,
+ type: input.type,
root: {
kind: "value",
value: {
@@ -131,7 +127,6 @@ export function createProvidedCandidate(input: ProvidedCandidateInput): Candidat
...(input.validation === undefined ? {} : { validation: input.validation }),
},
},
- fidelity: input.fidelity,
};
}
@@ -141,26 +136,16 @@ export function createProvidedCandidate(input: ProvidedCandidateInput): Candidat
* provenance. History makes no claim that the value satisfies the current author's meaning.
* No prior Operation, Command or outstanding execution state crosses the boundary.
*/
-export function createHistoricalCandidate(input: HistoricalCandidateInput): Candidate {
+export function createBuildRecordCandidate(input: BuildRecordCandidateInput): Candidate {
verifyBuildState(input.build);
- const currentOutput = resolveLogicalOutput(input.source, input.output);
- const sourceOutput = input.sourceOutput ?? input.output;
+ const sourceOutput = input.sourceOutput;
const selection = input.build.plan.selections.find((item) => item.output === sourceOutput);
assert(selection !== undefined, "HISTORICAL_OUTPUT_UNSELECTED", "historical Build did not select this Logical Output", sourceOutput);
const record = input.build.records.find((item) => item.id === selection.record);
assert(record !== undefined, "HISTORICAL_RECORD_MISSING", "historical Output Record is absent", selection.record);
- assert(
- record.type.module.name === currentOutput.type.module.name
- && record.type.module.version === currentOutput.type.module.version
- && record.type.name === currentOutput.type.name,
- "HISTORICAL_TYPE_MISMATCH",
- "historical Output Record has another Type",
- record.id,
- );
return createProvidedCandidate({
- output: input.output,
+ type: record.type,
value: record.value,
- fidelity: "substitute",
provenance: {
format: "svml.historical-output@1",
sourceBuild: input.build.id,
@@ -174,6 +159,9 @@ export function createHistoricalCandidate(input: HistoricalCandidateInput): Cand
});
}
+/** @deprecated Use createBuildRecordCandidate. */
+export const createHistoricalCandidate = createBuildRecordCandidate;
+
export function verifyRealizationOverlay(
program: LinkedProgram,
source: CompiledGraph,
@@ -185,7 +173,7 @@ export function verifyRealizationOverlay(
"OVERLAY_REQUIRES_AUTHOR_GRAPH",
"Realization Overlays attach to an author graph, not an already realized graph",
);
- assert(overlay.format === "svml.realization-overlay@1", "UNSUPPORTED_REALIZATION_OVERLAY", "unsupported Overlay format");
+ assert(overlay.format === "svml.realization-overlay@2", "UNSUPPORTED_REALIZATION_OVERLAY", "unsupported Overlay format");
assert(isDigest(overlay.id), "INVALID_OVERLAY_DIGEST", "Realization Overlay id is not a digest");
assert(overlay.id === digestOf(overlayContent(overlay)), "OVERLAY_DIGEST_MISMATCH", "Realization Overlay digest differs");
assert(overlay.sourceGraph === source.id, "OVERLAY_SOURCE_MISMATCH", "Realization Overlay targets another author graph");
@@ -193,7 +181,6 @@ export function verifyRealizationOverlay(
const candidateIds = new Set(source.candidates.map((candidate) => candidate.id));
for (const candidate of overlay.candidates) {
- resolveLogicalOutput(source, candidate.output);
assert(!candidateIds.has(candidate.id), "OVERLAY_CANDIDATE_CONFLICT", `Candidate ${candidate.id} already exists`);
assert(candidate.id.length > 0, "EMPTY_CANDIDATE_ID", "Overlay Candidate id is empty");
candidateIds.add(candidate.id);
@@ -205,7 +192,7 @@ function sealRealizationClosure(
overlays: readonly RealizationOverlay[],
): RealizationClosure {
const content = {
- format: "svml.realization-closure@1" as const,
+ format: "svml.realization-closure@2" as const,
sourceGraph,
overlays: overlays.map((overlay) => overlay.id).sort(),
};
@@ -222,20 +209,11 @@ export function resolveRealization(
const closure = sealRealizationClosure(source.id, overlays);
const candidates = overlays.flatMap((overlay) => overlay.candidates);
const operations = overlays.flatMap((overlay) => overlay.operations);
- const attachments = new Map<string, string[]>();
- for (const candidate of candidates) {
- const attached = attachments.get(candidate.output) ?? [];
- attached.push(candidate.id);
- attachments.set(candidate.output, attached);
- }
const graph = sealCompiledGraph({
program: source.program,
source: source.source,
realization: closure.id,
- outputs: source.outputs.map((output) => ({
- ...output,
- candidates: [...output.candidates, ...(attachments.get(output.id) ?? [])],
- })),
+ outputs: source.outputs,
candidates: [...source.candidates, ...candidates],
operations: [...source.operations, ...operations],
});
diff --git a/packages/realization/test/overlay.test.ts b/packages/realization/test/overlay.test.ts
index cec17b7e..6e210005 100644
--- a/packages/realization/test/overlay.test.ts
+++ b/packages/realization/test/overlay.test.ts
@@ -14,8 +14,8 @@ import {
start,
} from "@svml/core";
import {
- bindCandidateFragment,
elaborateGraphFragment,
+ exportRunFragment,
sealGraphFragment,
} from "@svml/elaborator";
import type {
@@ -28,7 +28,7 @@ import type {
TypeRef,
} from "@svml/protocol";
import {
- createHistoricalCandidate,
+ createBuildRecordCandidate,
createProvidedCandidate,
resolveRealization,
sealRealizationOverlay,
@@ -106,17 +106,15 @@ function fixture(): { readonly program: LinkedProgram; readonly source: Compiled
id: "shot.visual",
type: types.media,
primary: "shot.generate",
- candidates: ["shot.generate"],
semanticInputs: [{ kind: "record", id: "prompt:shot" }],
}],
candidates: [{
id: "shot.generate",
- output: "shot.visual",
+ type: types.media,
root: {
kind: "operation",
result: { kind: "operation-result", operation: "generate-shot" },
},
- fidelity: "exact",
}],
operations: [{
id: "generate-shot",
@@ -130,9 +128,8 @@ function fixture(): { readonly program: LinkedProgram; readonly source: Compiled
function providedOverlay(source: CompiledGraph, value: string, label: string) {
const candidate = createProvidedCandidate({
- output: "shot.visual",
+ type: types.media,
value: { kind: "inline", value },
- fidelity: "exact",
provenance: { library: "approved-shots", label },
});
return {
@@ -163,7 +160,7 @@ function completedAffinityBuild(): { readonly program: LinkedProgram; readonly s
const initial = start(base.program, source, sealBuildRequest({
graph: source.id,
targets: [{ output: "shot.visual", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
const ready = reduce(initial);
const command = ready.commands.find((item): item is InvokeProducerCommand => item.kind === "invoke-producer");
@@ -191,7 +188,7 @@ test("an attached Existing Value is inert until BuildRequest explicitly selects
const primary = start(program, realized.graph, sealBuildRequest({
graph: realized.graph.id,
targets: [{ output: "shot.visual", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
assert.deepEqual(primary.plan.steps.map((step) => step.id), ["generate-shot"]);
assert.deepEqual(primary.plan.initialValues, []);
@@ -199,7 +196,7 @@ test("an attached Existing Value is inert until BuildRequest explicitly selects
const selected = start(program, realized.graph, sealBuildRequest({
graph: realized.graph.id,
targets: [{ output: "shot.visual", accepts: "exact" }],
- bindings: [{ output: "shot.visual", candidate: candidate.id }],
+ satisfactions: [{ output: "shot.visual", candidate: candidate.id, fidelity: "exact" }],
}));
assert.deepEqual(selected.plan.steps, []);
assert.equal(selected.plan.initialValues[0]?.value.kind, "inline");
@@ -208,15 +205,15 @@ test("an attached Existing Value is inert until BuildRequest explicitly selects
test("a historical Record becomes an ordinary substitute zero-edge Candidate", () => {
const { program, source, state: historical } = completedAffinityBuild();
- const candidate = createHistoricalCandidate({ source, build: historical, output: "shot.visual" });
+ const candidate = createBuildRecordCandidate({ build: historical, sourceOutput: "shot.visual" });
assert.equal(candidate.root.kind, "value");
- assert.equal(candidate.fidelity, "substitute");
+ assert.deepEqual(candidate.type, types.media);
const overlay = sealRealizationOverlay({ sourceGraph: source.id, candidates: [candidate], operations: [] });
const realized = resolveRealization(program, source, [overlay]);
const fresh = start(program, realized.graph, sealBuildRequest({
graph: realized.graph.id,
targets: [{ output: "shot.visual", accepts: "substitute" }],
- bindings: [{ output: "shot.visual", candidate: candidate.id }],
+ satisfactions: [{ output: "shot.visual", candidate: candidate.id, fidelity: "substitute" }],
}));
assert.deepEqual(fresh.plan.steps, []);
assert.equal(fresh.plan.initialValues.length, 1);
@@ -227,16 +224,15 @@ test("a historical Record becomes an ordinary substitute zero-edge Candidate", (
test("a fixed black value substitutes an affined Output without any history or semantic proof", () => {
const { program, source } = completedAffinityBuild();
const candidate = createProvidedCandidate({
- output: "shot.visual",
+ type: types.media,
value: { kind: "inline", value: "UNRELATED FIXED BLACK VIDEO" },
- fidelity: "substitute",
});
const overlay = sealRealizationOverlay({ sourceGraph: source.id, candidates: [candidate], operations: [] });
const realized = resolveRealization(program, source, [overlay]);
const fresh = start(program, realized.graph, sealBuildRequest({
graph: realized.graph.id,
targets: [{ output: "shot.visual", accepts: "substitute" }],
- bindings: [{ output: "shot.visual", candidate: candidate.id }],
+ satisfactions: [{ output: "shot.visual", candidate: candidate.id, fidelity: "substitute" }],
}));
assert.deepEqual(fresh.plan.steps, []);
assert.equal(fresh.plan.initialValues.length, 1);
@@ -252,29 +248,27 @@ test("a historical Record may substitute another author graph and Output without
const other = sealCompiledGraph({
program: source.program,
outputs: source.outputs.map((output) => ({ ...output, id: "replacement.visual" })),
- candidates: source.candidates.map((candidate) => ({ ...candidate, output: "replacement.visual" })),
+ candidates: source.candidates,
operations: source.operations,
});
- const candidate = createHistoricalCandidate({
- source: other,
+ const candidate = createBuildRecordCandidate({
build: historical,
- output: "replacement.visual",
sourceOutput: "shot.visual",
});
- assert.equal(candidate.fidelity, "substitute");
+ assert.deepEqual(candidate.type, types.media);
const overlay = sealRealizationOverlay({ sourceGraph: other.id, candidates: [candidate], operations: [] });
const realized = resolveRealization(program, other, [overlay]);
assert.throws(() => start(program, realized.graph, sealBuildRequest({
graph: realized.graph.id,
targets: [{ output: "replacement.visual", accepts: "exact" }],
- bindings: [{ output: "replacement.visual", candidate: candidate.id }],
+ satisfactions: [{ output: "replacement.visual", candidate: candidate.id, fidelity: "substitute" }],
})), /selects a substitute path/u);
const fresh = start(program, realized.graph, sealBuildRequest({
graph: realized.graph.id,
targets: [{ output: "replacement.visual", accepts: "substitute" }],
- bindings: [{ output: "replacement.visual", candidate: candidate.id }],
+ satisfactions: [{ output: "replacement.visual", candidate: candidate.id, fidelity: "substitute" }],
}));
assert.deepEqual(fresh.plan.steps, []);
assert.equal(fresh.plan.initialValues[0]?.conformance, "substitute");
@@ -292,12 +286,12 @@ test("changing the attached Value changes Overlay, realized Graph and BuildReque
const requestLeft = sealBuildRequest({
graph: realizedLeft.graph.id,
targets: [{ output: "shot.visual", accepts: "exact" }],
- bindings: [{ output: "shot.visual", candidate: left.candidate.id }],
+ satisfactions: [{ output: "shot.visual", candidate: left.candidate.id, fidelity: "exact" }],
});
const requestRight = sealBuildRequest({
graph: realizedRight.graph.id,
targets: [{ output: "shot.visual", accepts: "exact" }],
- bindings: [{ output: "shot.visual", candidate: right.candidate.id }],
+ satisfactions: [{ output: "shot.visual", candidate: right.candidate.id, fidelity: "exact" }],
});
assert.notEqual(requestLeft.digest, requestRight.digest);
});
@@ -337,18 +331,22 @@ test("a static Fragment export can be attached as an external Candidate", () =>
fragment: fragment.id,
inputs: { prompt: { kind: "record", id: "prompt:shot" } },
});
- const contribution = bindCandidateFragment(instance, { visual: "shot.visual" });
+ const contribution = exportRunFragment(instance, ["visual"]);
const overlay = sealRealizationOverlay({
sourceGraph: source.id,
candidates: contribution.candidates,
operations: contribution.operations,
});
const realized = resolveRealization(program, source, [overlay]);
- const candidate = contribution.candidates[0]!;
+ const exported = contribution.exports[0]!;
const state = start(program, realized.graph, sealBuildRequest({
graph: realized.graph.id,
targets: [{ output: "shot.visual", accepts: "substitute" }],
- bindings: [{ output: "shot.visual", candidate: candidate.id }],
+ satisfactions: [{
+ output: "shot.visual",
+ candidate: exported.candidate,
+ fidelity: exported.suggestedFidelity,
+ }],
}));
assert.equal(state.plan.steps.length, 1);
assert.equal(state.plan.steps[0]?.producer.name, "preview");
@@ -360,14 +358,14 @@ test("tampered and cross-graph Overlays are rejected before Candidate selection"
const { overlay } = providedOverlay(source, "approved video", "v1");
const tampered = {
...overlay,
- candidates: overlay.candidates.map((candidate) => ({ ...candidate, fidelity: "substitute" as const })),
+ candidates: overlay.candidates.map((candidate) => ({ ...candidate, type: types.prompt })),
};
assert.throws(() => resolveRealization(program, source, [tampered]), /Overlay digest differs/u);
const otherSource = sealCompiledGraph({
program: source.program,
outputs: source.outputs.map((output) => ({ ...output, id: "other.visual" })),
- candidates: source.candidates.map((candidate) => ({ ...candidate, output: "other.visual" })),
+ candidates: source.candidates,
operations: source.operations,
});
assert.throws(
diff --git a/packages/realization/test/validation.test.ts b/packages/realization/test/validation.test.ts
index 08287bfc..ef8de6f2 100644
--- a/packages/realization/test/validation.test.ts
+++ b/packages/realization/test/validation.test.ts
@@ -67,14 +67,12 @@ function fixture() {
id: "media",
type: mediaType,
primary: "generated",
- candidates: ["generated"],
semanticInputs: [],
}],
candidates: [{
id: "generated",
- output: "media",
+ type: mediaType,
root: { kind: "operation", result: { kind: "operation-result", operation: "generate" } },
- fidelity: "exact",
}],
operations: [{
id: "generate",
@@ -102,9 +100,8 @@ test("provided Candidates pass the same Type-owner admission gate", async () =>
const validation = await validateValue(program.closure, mediaType, value, validators());
assert.ok(validation);
const accepted = createProvidedCandidate({
- output: "media",
+ type: mediaType,
value,
- fidelity: "exact",
validation,
});
assert.doesNotThrow(() => resolveRealization(program, source, [sealRealizationOverlay({
@@ -113,7 +110,7 @@ test("provided Candidates pass the same Type-owner admission gate", async () =>
operations: [],
})]));
- const missing = createProvidedCandidate({ output: "media", value, fidelity: "exact" });
+ const missing = createProvidedCandidate({ type: mediaType, value });
assert.throws(
() => resolveRealization(program, source, [sealRealizationOverlay({
sourceGraph: source.id,
@@ -124,9 +121,8 @@ test("provided Candidates pass the same Type-owner admission gate", async () =>
);
const tampered = createProvidedCandidate({
- output: "media",
+ type: mediaType,
value,
- fidelity: "exact",
validation: { ...validation, recordDigest: digestOf("another-value") },
});
assert.throws(
diff --git a/packages/speech-program/test/surface.test.ts b/packages/speech-program/test/surface.test.ts
index 9b0bb2c9..4cf770a8 100644
--- a/packages/speech-program/test/surface.test.ts
+++ b/packages/speech-program/test/surface.test.ts
@@ -115,7 +115,7 @@ test("Speech Spine lowers ordered Takes into media normalization, one audio plan
const build = start(compiled.program, compiled.elaboration.graph, sealBuildRequest({
graph: compiled.elaboration.graph.id,
targets: [{ output: target.ref.kind === "logical-output" ? target.ref.id : "", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
const names = build.plan.steps.map((step) => step.producer.name);
assert.equal(names.filter((name) => name === mediaPipelineProducers.inspect.name).length, 2);
diff --git a/packages/speech-program/test/video-pipeline-fixture.ts b/packages/speech-program/test/video-pipeline-fixture.ts
index 2cb78501..1c37246e 100644
--- a/packages/speech-program/test/video-pipeline-fixture.ts
+++ b/packages/speech-program/test/video-pipeline-fixture.ts
@@ -22,6 +22,7 @@ import {
sealGraphFragment,
} from "@svml/elaborator";
import type {
+ CandidateBinding,
BuildState,
CapabilityRef,
CompiledGraph,
@@ -343,14 +344,14 @@ export type VideoFixture = {
readonly program: LinkedProgram;
readonly source: CompiledGraph;
readonly graph: CompiledGraph;
- readonly bindings: readonly { readonly output: string; readonly candidate: string }[];
+ readonly satisfactions: readonly CandidateBinding[];
};
export function createVideoFixture(options: VideoBuildOptions = {}): VideoFixture {
const program = authorProgram();
const source = createVideoGraph(program);
if (options.estimateRealization !== "placeholder") {
- return { program, source, graph: source, bindings: [] };
+ return { program, source, graph: source, satisfactions: [] };
}
const placeholder = elaborateGraphFragment(program, placeholderEstimateFragment, {
id: "opening.placeholder-estimate",
@@ -368,7 +369,7 @@ export function createVideoFixture(options: VideoBuildOptions = {}): VideoFixtur
program,
source,
graph: realized.graph,
- bindings: [{ output: videoOutputs.estimate, candidate: contribution.candidates[0]!.id }],
+ satisfactions: contribution.satisfactions ?? [],
};
}
@@ -379,7 +380,7 @@ export function createVideoBuild(options: VideoBuildOptions = {}): BuildState {
const request = sealBuildRequest({
graph: fixture.graph.id,
targets: targets.map((name) => ({ output: videoOutputs[name], accepts })),
- bindings: fixture.bindings,
+ satisfactions: fixture.satisfactions,
});
return start(fixture.program, fixture.graph, request);
}
diff --git a/packages/speech-program/test/video-pipeline.test.ts b/packages/speech-program/test/video-pipeline.test.ts
index 3d0d4d75..63c5558f 100644
--- a/packages/speech-program/test/video-pipeline.test.ts
+++ b/packages/speech-program/test/video-pipeline.test.ts
@@ -569,9 +569,8 @@ test("an Existing SpeechTake cuts generation while a visual substitute cuts the
segments: [{ segmentId: "line", startSec: 0, endSec: 1 }],
});
const takeCandidate = createProvidedCandidate({
- output: videoOutputs.take,
+ type: contractTypes.speechBasis,
value: { kind: "inline", value: existingTake },
- fidelity: "exact",
provenance: { source: "approved-library", name: "opening-v3" },
});
const takeOverlay = sealRealizationOverlay({
@@ -583,7 +582,7 @@ test("an Existing SpeechTake cuts generation while a visual substitute cuts the
const captionFromExisting = start(fixture.program, withExistingTake.graph, sealBuildRequest({
graph: withExistingTake.graph.id,
targets: [{ output: videoOutputs.caption, accepts: "exact" }],
- bindings: [{ output: videoOutputs.take, candidate: takeCandidate.id }],
+ satisfactions: [{ output: videoOutputs.take, candidate: takeCandidate.id, fidelity: "exact" }],
}));
assert.equal(producerCount(captionFromExisting, videoProducers.requestEstimate), 0);
assert.equal(producerCount(captionFromExisting, videoProducers.requestSeedanceMini), 0);
@@ -612,9 +611,8 @@ test("an Existing SpeechTake cuts generation while a visual substitute cuts the
validatorRegistry(),
);
const blackCandidate = createProvidedCandidate({
- output: videoOutputs.visual,
+ type: contractTypes.visualTrack,
value: blackValue,
- fidelity: "substitute",
provenance: { method: "black-preview" },
...(blackValidation === undefined ? {} : { validation: blackValidation }),
});
@@ -627,7 +625,7 @@ test("an Existing SpeechTake cuts generation while a visual substitute cuts the
const preview = start(fixture.program, withBlack.graph, sealBuildRequest({
graph: withBlack.graph.id,
targets: [{ output: videoOutputs.visual, accepts: "substitute" }],
- bindings: [{ output: videoOutputs.visual, candidate: blackCandidate.id }],
+ satisfactions: [{ output: videoOutputs.visual, candidate: blackCandidate.id, fidelity: "substitute" }],
}));
assert.deepEqual(preview.plan.steps, []);
assert.equal(preview.plan.initialValues.length, 1);
diff --git a/packages/speech-take/test/product.test.ts b/packages/speech-take/test/product.test.ts
index 204557bc..7a793315 100644
--- a/packages/speech-take/test/product.test.ts
+++ b/packages/speech-take/test/product.test.ts
@@ -153,14 +153,12 @@ function createGraph(program: LinkedProgram): CompiledGraph {
id: "opening.take",
type: contractTypes.speechBasis,
primary: "opening.take.generate",
- candidates: ["opening.take.generate", "opening.take.existing"],
semanticInputs: [record("request:opening")],
},
{
id: "opening.audio",
type: contractTypes.speechAudioBasis,
primary: "opening.audio.project",
- candidates: ["opening.audio.project"],
semanticInputs: [output("opening.take")],
affinity: [
{
@@ -179,7 +177,6 @@ function createGraph(program: LinkedProgram): CompiledGraph {
id: "opening.visual",
type: contractTypes.visualTrack,
primary: "opening.visual.project",
- candidates: ["opening.visual.project", "opening.visual.existing"],
semanticInputs: [output("opening.take")],
affinity: [{
resultPointer: "/programSpaceDigest",
@@ -191,13 +188,12 @@ function createGraph(program: LinkedProgram): CompiledGraph {
candidates: [
{
id: "opening.take.generate",
- output: "opening.take",
+ type: contractTypes.speechBasis,
root: { kind: "operation", result: operation("generate-opening") },
- fidelity: "exact",
},
{
id: "opening.take.existing",
- output: "opening.take",
+ type: contractTypes.speechBasis,
root: {
kind: "value",
value: {
@@ -206,23 +202,20 @@ function createGraph(program: LinkedProgram): CompiledGraph {
provenance: { library: "approved-takes", take: "opening-v2" },
},
},
- fidelity: "exact",
},
{
id: "opening.audio.project",
- output: "opening.audio",
+ type: contractTypes.speechAudioBasis,
root: { kind: "operation", result: operation("project-opening-audio") },
- fidelity: "exact",
},
{
id: "opening.visual.project",
- output: "opening.visual",
+ type: contractTypes.visualTrack,
root: { kind: "operation", result: operation("project-opening-visual") },
- fidelity: "exact",
},
{
id: "opening.visual.existing",
- output: "opening.visual",
+ type: contractTypes.visualTrack,
root: {
kind: "value",
value: {
@@ -232,7 +225,6 @@ function createGraph(program: LinkedProgram): CompiledGraph {
validation: existingVisualValidation,
},
},
- fidelity: "substitute",
},
],
operations: [
@@ -260,14 +252,18 @@ function createGraph(program: LinkedProgram): CompiledGraph {
function build(
targetAccepts: Readonly<Record<string, "exact" | "substitute">>,
- bindings: Readonly<Record<string, string>> = {},
+ satisfactionMap: Readonly<Record<string, string>> = {},
) {
const program = createProgram();
const graph = createGraph(program);
const request: BuildRequest = sealBuildRequest({
graph: graph.id,
targets: Object.entries(targetAccepts).map(([outputId, accepts]) => ({ output: outputId, accepts })),
- bindings: Object.entries(bindings).map(([outputId, candidate]) => ({ output: outputId, candidate })),
+ satisfactions: Object.entries(satisfactionMap).map(([outputId, candidate]) => ({
+ output: outputId,
+ candidate,
+ fidelity: candidate === "opening.visual.existing" ? "substitute" as const : "exact" as const,
+ })),
});
return start(program, graph, request);
}
diff --git a/packages/svs/test/source-closure.test.ts b/packages/svs/test/source-closure.test.ts
index 9016b9f2..32b18d9d 100644
--- a/packages/svs/test/source-closure.test.ts
+++ b/packages/svs/test/source-closure.test.ts
@@ -248,7 +248,7 @@ test("Text and SVS recursively compile one aliased Recipe into a Core BuildPlan"
const state = start(compiled.program, compiled.elaboration.graph, sealBuildRequest({
graph: compiled.elaboration.graph.id,
targets: [{ output: target.ref.kind === "logical-output" ? target.ref.id : "", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
assert.equal(state.plan.steps.length, 1);
assert.equal(state.plan.steps[0]?.producer.name, renderProducer.name);
diff --git a/packages/text/test/author-integration.test.ts b/packages/text/test/author-integration.test.ts
index 4de3f9a8..fa6c4533 100644
--- a/packages/text/test/author-integration.test.ts
+++ b/packages/text/test/author-integration.test.ts
@@ -258,7 +258,7 @@ test("Text Surfaces compile forward author references into a Core BuildPlan", as
const state = start(program, elaborated.graph, sealBuildRequest({
graph: elaborated.graph.id,
targets: [{ output: "final.result", accepts: "exact" }],
- bindings: [],
+ satisfactions: [],
}));
assert.deepEqual(