mirror of
https://github.com/hypit-ai/hypit.git
synced 2026-11-18 20:20:34 +00:00
271 lines
8.4 KiB
TypeScript
271 lines
8.4 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
|
|
// This suite verifies Executor handoff to Type-owner validation.
|
|
|
|
import {
|
|
createResolvedClosure,
|
|
defineBuild,
|
|
link,
|
|
materializeBuild,
|
|
planBuild,
|
|
sealAuthorGraph,
|
|
verifyRecordStructure,
|
|
} from "@hypit/kernel";
|
|
import {
|
|
ProducerRegistry,
|
|
Executor,
|
|
EndpointRegistry,
|
|
} from "@hypit/executor";
|
|
import { InProcessBuildScheduler } from "@hypit/runtime";
|
|
import type {
|
|
CapabilityRef,
|
|
AuthorGraph,
|
|
LinkedProgram,
|
|
ModuleManifest,
|
|
ProducerRef,
|
|
TypeRef,
|
|
} from "@hypit/protocol";
|
|
import type { BuildView } from "@hypit/kernel";
|
|
import {
|
|
RefinementError,
|
|
RefinementRegistry,
|
|
refineRecord,
|
|
refineValue,
|
|
} from "@hypit/refinement";
|
|
|
|
const contractModule = { name: "example.measurement-contract", version: "1.0.0" } as const;
|
|
const sensorModule = { name: "example.sensor", version: "1.0.0" } as const;
|
|
const reportModule = { name: "example.report", version: "1.0.0" } as const;
|
|
|
|
const measurementType = { module: contractModule, name: "Measurement" } satisfies TypeRef;
|
|
const reportType = { module: reportModule, name: "Report" } satisfies TypeRef;
|
|
const measurementCapability = {
|
|
module: sensorModule,
|
|
name: "obtain-measurement",
|
|
} satisfies CapabilityRef;
|
|
const measureProducer = { module: sensorModule, name: "measure" } satisfies ProducerRef;
|
|
const requestProducer = { module: sensorModule, name: "request-measurement" } satisfies ProducerRef;
|
|
const reportProducer = { module: reportModule, name: "write-report" } satisfies ProducerRef;
|
|
|
|
async function runBuild(executor: Executor, state: BuildView) {
|
|
return (await new InProcessBuildScheduler(executor).run([{
|
|
id: "validation-test",
|
|
definition: { format: "hypit.build-definition@1", program: state.program, plan: state.plan },
|
|
facts: [],
|
|
}]))[0]!;
|
|
}
|
|
|
|
const contractManifest: ModuleManifest = {
|
|
format: "hypit.module@1",
|
|
name: contractModule.name,
|
|
version: contractModule.version,
|
|
dependencies: [],
|
|
types: [measurementType.name],
|
|
capabilities: [],
|
|
producers: [],
|
|
};
|
|
|
|
const contractDependency = contractModule;
|
|
|
|
const sensorManifest: ModuleManifest = {
|
|
format: "hypit.module@1",
|
|
name: sensorModule.name,
|
|
version: sensorModule.version,
|
|
dependencies: [contractDependency],
|
|
types: [],
|
|
capabilities: [{ name: measurementCapability.name, returns: measurementType }],
|
|
producers: [
|
|
{
|
|
name: measureProducer.name,
|
|
inputs: [],
|
|
result: { kind: "output" as const, name: "measurement", type: measurementType },
|
|
},
|
|
{
|
|
name: requestProducer.name,
|
|
inputs: [],
|
|
result: { kind: "need" as const, name: "measurement", capability: measurementCapability },
|
|
},
|
|
],
|
|
};
|
|
|
|
const reportManifest: ModuleManifest = {
|
|
format: "hypit.module@1",
|
|
name: reportModule.name,
|
|
version: reportModule.version,
|
|
dependencies: [contractDependency],
|
|
types: [reportType.name],
|
|
capabilities: [],
|
|
producers: [{
|
|
name: reportProducer.name,
|
|
inputs: [{ name: "measurement", type: measurementType }],
|
|
result: { kind: "output" as const, name: "report", type: reportType },
|
|
}],
|
|
};
|
|
|
|
function registry(): RefinementRegistry {
|
|
const refinements = new RefinementRegistry();
|
|
refinements.register(measurementType, ({ value }) => {
|
|
if (value === null || Array.isArray(value) || typeof value !== "object") {
|
|
throw new Error("measurement must be an object");
|
|
}
|
|
const measured = (value as Readonly<Record<string, unknown>>).value;
|
|
if (typeof measured !== "number" || measured % 2 !== 0) {
|
|
throw new Error("measurement must be even");
|
|
}
|
|
});
|
|
return refinements;
|
|
}
|
|
|
|
function program(): LinkedProgram {
|
|
const closure = createResolvedClosure([contractManifest, sensorManifest, reportManifest]);
|
|
return link(closure, []);
|
|
}
|
|
|
|
function outputGraph(): AuthorGraph {
|
|
return sealAuthorGraph({
|
|
outputs: [
|
|
{
|
|
id: "measurement",
|
|
type: measurementType,
|
|
primary: { kind: "operation-result", operation: "measure" },
|
|
},
|
|
{
|
|
id: "report",
|
|
type: reportType,
|
|
primary: { kind: "operation-result", operation: "report" },
|
|
},
|
|
],
|
|
operations: [
|
|
{
|
|
id: "measure",
|
|
producer: measureProducer,
|
|
inputs: {},
|
|
result: { kind: "output" as const, name: "measurement", record: "measurement:root" },
|
|
},
|
|
{
|
|
id: "report",
|
|
producer: reportProducer,
|
|
inputs: { measurement: { kind: "logical-output", id: "measurement" } },
|
|
result: { kind: "output" as const, name: "report", record: "report:root" },
|
|
},
|
|
],
|
|
});
|
|
}
|
|
|
|
function outputBuild(linked: LinkedProgram, graph = outputGraph()) {
|
|
return buildState(linked, graph, ["report"]);
|
|
}
|
|
|
|
function buildState(linked: LinkedProgram, graph: AuthorGraph, targets: readonly string[]) {
|
|
const planned = planBuild(linked, graph, targets, []);
|
|
return materializeBuild(defineBuild({
|
|
program: linked,
|
|
plan: planned.plan,
|
|
}), []);
|
|
}
|
|
|
|
function hosts(measured: number): ProducerRegistry {
|
|
const hosts = new ProducerRegistry();
|
|
hosts.registerProducer(measureProducer, () => ({ kind: "output", value: ({ value: measured, unit: "ticks" }) }));
|
|
hosts.registerProducer(reportProducer, ({ inputs }) => ({ kind: "output", value: (`accepted:${JSON.stringify(inputs.measurement?.value)}`) }));
|
|
return hosts;
|
|
}
|
|
|
|
test("three independent packages communicate through an owner-validated nominal Type", async () => {
|
|
const linked = program();
|
|
const result = await runBuild(new Executor({
|
|
producers: hosts(4),
|
|
refinements: registry(),
|
|
}), outputBuild(linked));
|
|
|
|
assert.equal(result.status, "complete");
|
|
const measurement = result.state.records.find((record) => record.id === "measurement:root");
|
|
assert.equal(result.state.records.find((record) => record.id === "report:root")?.type.name, "Report");
|
|
|
|
});
|
|
|
|
test("a structurally valid but semantically invalid Producer value never enters BuildView", async () => {
|
|
const linked = program();
|
|
const result = await runBuild(new Executor({
|
|
producers: hosts(3),
|
|
refinements: registry(),
|
|
}), outputBuild(linked));
|
|
|
|
assert.equal(result.status, "failed");
|
|
assert.match(result.outcomes[0]?.message ?? "", /measurement must be even/u);
|
|
assert.equal(result.state.records.some((record) => record.id === "measurement:root"), false);
|
|
});
|
|
|
|
function providerGraph(): AuthorGraph {
|
|
return sealAuthorGraph({
|
|
outputs: [{
|
|
id: "measurement",
|
|
type: measurementType,
|
|
primary: { kind: "operation-result", operation: "request" },
|
|
}],
|
|
operations: [{
|
|
id: "request",
|
|
producer: requestProducer,
|
|
inputs: {},
|
|
result: {
|
|
kind: "need",
|
|
name: "measurement",
|
|
id: "need:measurement",
|
|
record: "measurement:endpoint",
|
|
},
|
|
}],
|
|
});
|
|
}
|
|
|
|
async function providerBuild(measured: number) {
|
|
const linked = program();
|
|
const graph = providerGraph();
|
|
const hosts = new ProducerRegistry();
|
|
hosts.registerProducer(requestProducer, () => ({ kind: "need", constraints: { sample: "latest" } }));
|
|
const endpoints = new EndpointRegistry();
|
|
endpoints.registerImmediateEndpoint(
|
|
"example:measurement-endpoint",
|
|
measurementCapability,
|
|
measurementType,
|
|
() => ({ value: measured, unit: "ticks" }),
|
|
);
|
|
return await runBuild(
|
|
new Executor({ producers: hosts, endpoints, refinements: registry() }),
|
|
buildState(linked, graph, ["measurement"]),
|
|
);
|
|
}
|
|
|
|
test("Endpoint results pass the same Type-owner validation gate as Producer results", async () => {
|
|
const valid = await providerBuild(8);
|
|
assert.equal(valid.status, "complete");
|
|
|
|
const invalid = await providerBuild(7);
|
|
assert.equal(invalid.status, "failed");
|
|
assert.match(invalid.outcomes.at(-1)?.message ?? "", /measurement must be even/u);
|
|
assert.equal(invalid.state.records.some((record) => record.id === "measurement:endpoint"), false);
|
|
});
|
|
|
|
test("authored values cross the Type owner's validation gate without carrying validation metadata", async () => {
|
|
const linked = program();
|
|
const raw = ({
|
|
id: "measurement:authored",
|
|
type: measurementType,
|
|
value: ({ value: 10, unit: "ticks" }),
|
|
});
|
|
verifyRecordStructure(linked.closure, raw);
|
|
await refineRecord(raw, registry());
|
|
verifyRecordStructure(linked.closure, raw);
|
|
});
|
|
|
|
test("Type validation errors remain machine distinguishable", async () => {
|
|
await assert.rejects(
|
|
() => refineValue(
|
|
measurementType,
|
|
({ value: 9, unit: "ticks" }),
|
|
registry(),
|
|
),
|
|
(error: unknown) => error instanceof RefinementError && error.code === "TYPE_REFINEMENT_REJECTED",
|
|
);
|
|
});
|