@orkestrel/probe 0.0.1

package/dist/src/core/index.js

@@ -0,0 +1,706 @@
+import { andOf, arrayOf, arrayShape, holds, isError, isNonEmptyString, isNumber, isString, literalOf, literalShape, objectShape, recordOf, stringShape } from "@orkestrel/contract";
+//#region src/core/constants.ts
+/**
+* Lists the stages a claim passes through, in the order a verdict reports them.
+*
+* @remarks
+* One list feeds the `Stage` type, the wire shape, the stage guard, and the receipt computation, so
+* a stage cannot be admitted by one and refused by another. The type derives from this list rather
+* than standing beside it, so a stage the list omits is a stage no member of the union names.
+*
+* @example
+* ```ts
+* PROBE_STAGES // ['type', 'lint', 'runtime']
+* ```
+*/
+var PROBE_STAGES = Object.freeze([
+	"type",
+	"lint",
+	"runtime"
+]);
+/**
+* Lists the parties that can own action on an issue or probe failure.
+*
+* @remarks
+* One list feeds the `Party` type and its guard, so a party cannot be admitted by one and refused
+* by another.
+*
+* @example
+* ```ts
+* PROBE_PARTIES // ['claimant', 'workspace', 'instrument']
+* ```
+*/
+var PROBE_PARTIES = Object.freeze([
+	"claimant",
+	"workspace",
+	"instrument"
+]);
+/**
+* Lists the conditions that can end a probe operation.
+*
+* @remarks
+* One list feeds the code union and the error guard, so a condition cannot be constructed by one
+* and refused by the other. The guard reads this list rather than the class, which is what lets it
+* refuse a lookalike carrying a condition this package never declared.
+*
+* @example
+* ```ts
+* PROBE_ERROR_CODES // ['refused', 'missing', 'malformed', 'destroyed', 'deadline']
+* ```
+*/
+var PROBE_ERROR_CODES = Object.freeze([
+	"refused",
+	"missing",
+	"malformed",
+	"destroyed",
+	"deadline"
+]);
+/**
+* Names the leading token every receipt carries.
+*
+* @remarks
+* A receipt travels away from the verdict that minted it — an agent pastes it into the promotion
+* action — so it names itself rather than relying on where it was found.
+*
+* @example
+* ```ts
+* const receipt =
+* 	'probe:6ca20c3bff623031d3955b9d1a76d71d:type:typescript@6.0.3:oxlint@1.79.0:vitest@4.1.11:configs/src/tsconfig.core.json@3b674fdf121c85efb9ed1bab25ceeec8'
+* receipt.startsWith(RECEIPT_PREFIX) // true
+* ```
+*/
+var RECEIPT_PREFIX = "probe";
+/**
+* Names the character joining a receipt's tokens.
+*
+* @remarks
+* A project path can contain this character, so the project field goes last and a reader rejoins
+* every field from index 6 onward with this separator rather than expecting a fixed count.
+*
+* @example
+* ```ts
+* const receipt =
+* 	'probe:6ca20c3bff623031d3955b9d1a76d71d:type:typescript@6.0.3:oxlint@1.79.0:vitest@4.1.11:configs/src/tsconfig.core.json@3b674fdf121c85efb9ed1bab25ceeec8'
+* receipt.split(RECEIPT_SEPARATOR).length // 7
+* ```
+*/
+var RECEIPT_SEPARATOR = ":";
+//#endregion
+//#region src/core/errors.ts
+/**
+* Reports one probe failure under stable ownership and condition axes.
+*
+* @remarks
+* Every failure raised while serving a claim arrives as one of these, so a consumer catching from
+* `prove`, from a stage, or from a workspace leaf branches on {@link Party} and
+* {@link ProbeErrorCode} rather than on message text. Narrow a caught value with
+* {@link isProbeError} before reading either member. A pure leaf called directly with a value
+* `isClaim` would refuse raises the host's own fault unchanged, because those leaves are written to
+* be total over a validated claim rather than over every value.
+*
+* @example
+* ```ts
+* const error = new ProbeError('Path escapes the workspace: ../secrets.env', {
+* 	origin: 'claimant',
+* 	code: 'refused',
+* 	context: { path: '../secrets.env' },
+* })
+* error.origin // 'claimant'
+* error.code // 'refused'
+* error.context?.path // '../secrets.env'
+* ```
+*/
+var ProbeError = class extends Error {
+	name = "ProbeError";
+	origin;
+	code;
+	context;
+	/**
+	* Creates one classified probe failure.
+	*
+	* @param message - Human-readable description of what failed
+	* @param options - The ownership, condition, optional structured context, and optional cause
+	*/
+	constructor(message, options) {
+		const cause = options.cause;
+		super(message, cause === void 0 ? void 0 : { cause });
+		Object.defineProperty(this, Symbol.for("@orkestrel/probe.error"), { value: true });
+		this.origin = options.origin;
+		this.code = options.code;
+		if (options.context !== void 0) this.context = options.context;
+	}
+};
+/**
+* Checks whether an unknown value is a {@link ProbeError}.
+*
+* @remarks
+* Recognition combines the global own-property brand with the native `Error` base, the subclass
+* prototype, the fixed name, a party {@link PROBE_PARTIES} declares, and a condition
+* {@link PROBE_ERROR_CODES} declares. The brand carries recognition across duplicate installations
+* and across an ESM and a CommonJS copy of this package, where the two classes are different values.
+* A plain `Error`, a property-only lookalike, and a branded value carrying an undeclared origin or
+* condition all stay outside the type.
+*
+* @param value - The value to inspect
+* @returns True only for a `ProbeError` instance; false otherwise
+*
+* @example
+* ```ts
+* isProbeError(createDestroyedError('probe')) // true
+* isProbeError(new Error('The probe has been destroyed')) // false
+* ```
+*/
+function isProbeError(value) {
+	if (!isError(value)) return false;
+	return holds(() => {
+		if (Object.getPrototypeOf(value) === Error.prototype) return false;
+		if (value.name !== "ProbeError" || !("origin" in value) || !("code" in value)) return false;
+		if (Object.getOwnPropertyDescriptor(value, Symbol.for("@orkestrel/probe.error"))?.value !== true) return false;
+		const origin = value.origin;
+		const code = value.code;
+		return PROBE_PARTIES.some((declared) => declared === origin) && PROBE_ERROR_CODES.some((declared) => declared === code);
+	});
+}
+/**
+* Creates the failure raised when an instrument is used after it was torn down.
+*
+* @remarks
+* Every resident entity in this package refuses this way, so the subject names which one in the
+* message and the condition is the same for all of them. A caller that meets this builds a
+* replacement rather than retrying: teardown is permanent.
+*
+* @param subject - The torn-down entity, named as the message names it, such as `type stage`
+* @returns A typed teardown failure
+*
+* @example
+* ```ts
+* createDestroyedError('type stage').message // 'The type stage has been destroyed'
+* createDestroyedError('probe').code // 'destroyed'
+* ```
+*/
+function createDestroyedError(subject) {
+	return new ProbeError(`The ${subject} has been destroyed`, {
+		origin: "claimant",
+		code: "destroyed"
+	});
+}
+//#endregion
+//#region src/core/validators.ts
+/**
+* Checks whether a value names a stage.
+*
+* @param value - The value to check
+* @returns True if the value is a stage name; false otherwise
+*
+* @example
+* ```ts
+* isStage('lint') // true
+* isStage('typecheck') // false
+* ```
+*/
+var isStage = literalOf(PROBE_STAGES);
+/**
+* Checks whether a value carries a proposed file's path and text.
+*
+* @remarks
+* Rejects an empty, absolute, or workspace-escaping path. A contained relative path may contain
+* `.` or may traverse to a parent that remains inside the workspace. Every stage resolves a file
+* by that path, so admitting an escape here would defer the refusal until a stage had already
+* accepted the draft. An `Issue` carries no such minimum because this package produces issues
+* rather than admits them.
+*
+* @param value - The value to check
+* @returns True if the value is a draft; false otherwise
+*
+* @example
+* ```ts
+* isDraft({ path: 'src/core/greeting.ts', text: 'export const GREETING = "hi"\n' }) // true
+* isDraft({ path: '../../etc/hosts', text: '' }) // false
+* isDraft({ path: 'src/core/greeting.ts' }) // false
+* ```
+*/
+var isDraft = recordOf({
+	path: andOf(isNonEmptyString, (path) => {
+		if (/^(?:[\\/]|[A-Za-z]:)/.test(path)) return false;
+		let depth = 0;
+		for (const segment of path.split(/[\\/]+/)) {
+			if (segment === "" || segment === ".") continue;
+			if (segment !== "..") {
+				depth += 1;
+				continue;
+			}
+			if (depth === 0) return false;
+			depth -= 1;
+		}
+		return true;
+	}),
+	text: isString
+});
+/**
+* Checks whether a value carries a claim's candidate drafts and its test.
+*
+* @param value - The value to check
+* @returns True if the value is a case; false otherwise
+*
+* @example
+* ```ts
+* const test = { path: 'tests/src/core/greeting.test.ts', text: 'test("greets", () => {})\n' }
+* isCase({ files: [], test }) // true
+* ```
+*/
+var isCase = recordOf({
+	files: arrayOf(isDraft),
+	test: isDraft
+});
+/**
+* Checks whether a value carries a case plus the stage and reason it must fail for.
+*
+* @param value - The value to check
+* @returns True if the value is a control; false otherwise
+*
+* @example
+* ```ts
+* const test = { path: 'tests/src/core/greeting.test.ts', text: 'test("greets", () => {})\n' }
+* isControl({ files: [], test, stage: 'type', reason: 'must not compile' }) // true
+* isControl({ files: [], test }) // false
+* ```
+*/
+var isControl = recordOf({
+	files: arrayOf(isDraft),
+	test: isDraft,
+	stage: isStage,
+	reason: isNonEmptyString
+});
+/**
+* Checks whether a value carries a project, a case, and a control.
+*
+* @remarks
+* Exact rather than open: a claim is this package's own record, so an unknown member is a caller
+* sending a contract this service does not implement rather than a wider caller it must tolerate.
+*
+* `CLAIM_SHAPE` is the wire contract's shape and this is the admission rule the tool enforces, and
+* the rule is strictly narrower than the shape. They agree on every member but `Draft.path`: the
+* shape constrains it to a non-empty string, while `isDraft` also refuses an absolute path
+* and one that traverses out of the workspace, so `../../etc/hosts` satisfies
+* `compileGuard(CLAIM_SHAPE)` and is refused here. `ProbeServer` advertises the shape and enforces
+* this rule, so it names the refused member rather than reporting only that the claim was invalid.
+*
+* @param value - The value to check
+* @returns True if the value is a claim; false otherwise
+*
+* @example
+* ```ts
+* isClaim({ project: 'tsconfig.json', case: subject, control }) // true
+* isClaim({ project: 'tsconfig.json', case: subject }) // false
+* ```
+*/
+var isClaim = recordOf({
+	project: isNonEmptyString,
+	case: isCase,
+	control: isControl
+});
+/**
+* Checks whether a value names a party an issue carries.
+*
+* @param value - The value to check
+* @returns True if the value is a party; false otherwise
+*
+* @example
+* ```ts
+* isParty('claimant') // true
+* isParty('workspace') // true
+* isParty('instrument') // true
+* isParty('stage') // false
+* ```
+*/
+var isParty = literalOf(PROBE_PARTIES);
+/**
+* Checks whether a value carries one message, its location, and the origin of the fault it names.
+*
+* @remarks
+* `origin` is required rather than optional. Every issue this package produces sets it, and a
+* receipt turns on it: a control's issue disproves the claim only when its origin names the
+* claimant.
+*
+* @param value - The value to check
+* @returns True if the value is an issue; false otherwise
+*
+* @example
+* ```ts
+* isIssue({ origin: 'claimant', path: 'src/core/greeting.ts', message: 'not assignable' }) // true
+* isIssue({ path: 'src/core/greeting.ts', message: 'not assignable' }) // false
+* ```
+*/
+var isIssue = recordOf({
+	origin: isParty,
+	path: isString,
+	message: isString,
+	line: isNumber
+}, ["line"]);
+/**
+* Checks whether a value carries one stage's outcome.
+*
+* @param value - The value to check
+* @returns True if the value is a check; false otherwise
+*
+* @example
+* ```ts
+* isCheck({ stage: 'lint', elapsed: 17, issues: [] }) // true
+* ```
+*/
+var isCheck = recordOf({
+	stage: isStage,
+	elapsed: isNumber,
+	issues: arrayOf(isIssue)
+});
+/**
+* Checks whether a value names every resolved tool version.
+*
+* @param value - The value to check
+* @returns True if the value is a toolchain; false otherwise
+*
+* @example
+* ```ts
+* isToolchain({ typescript: '6.0.3', oxlint: '1.79.0', vitest: '4.1.11' }) // true
+* isToolchain({ typescript: '6.0.3' }) // false
+* ```
+*/
+var isToolchain = recordOf({
+	typescript: isString,
+	oxlint: isString,
+	vitest: isString
+});
+/**
+* Checks whether a value names one resolved TypeScript project and what it contained.
+*
+* @remarks
+* Rejects an empty path and an empty digest. A verdict names the project that judged it, so a
+* blank member here would report a project the type stage never applied.
+*
+* @param value - The value to check
+* @returns True if the value is a project; false otherwise
+*
+* @example
+* ```ts
+* isProject({ path: 'configs/src/tsconfig.core.json', digest: '3b674fdf121c85ef' }) // true
+* isProject({ path: 'configs/src/tsconfig.core.json', digest: '' }) // false
+* ```
+*/
+var isProject = recordOf({
+	path: isNonEmptyString,
+	digest: isNonEmptyString
+});
+/**
+* Checks whether a value carries a complete verdict.
+*
+* @remarks
+* Accepts any check count, because arity is the coordinator's obligation rather than this guard's:
+* a stage that could not start throws before a verdict is built, so a short list can only arrive
+* from a caller that assembled one by hand.
+*
+* @param value - The value to check
+* @returns True if the value is a verdict; false otherwise
+*
+* @example
+* ```ts
+* const basis = { id: '01J8Z0', digest: '6ca20c3b', toolchain, project, elapsed: 337 }
+* isVerdict({ ...basis, case: [], control: [] }) // true
+* isVerdict({ ...basis, case: [] }) // false
+* ```
+*/
+var isVerdict = recordOf({
+	id: isString,
+	digest: isString,
+	toolchain: isToolchain,
+	project: isProject,
+	reason: isNonEmptyString,
+	case: arrayOf(isCheck),
+	control: arrayOf(isCheck),
+	elapsed: isNumber,
+	receipt: isString
+}, ["reason", "receipt"]);
+//#endregion
+//#region src/core/helpers.ts
+/**
+* Renders one tool message as a single line an agent can classify and locate.
+*
+* @param issue - The message and location a stage reported
+* @returns The bracketed origin, location, and message, separated by spaces
+*
+* @example
+* ```ts
+* const located: Issue = {
+* 	origin: 'claimant',
+* 	path: 'src/core/greeting.ts',
+* 	message: 'not assignable',
+* 	line: 1,
+* }
+* const whole: Issue = {
+* 	origin: 'claimant',
+* 	path: 'src/core/greeting.ts',
+* 	message: 'not assignable',
+* }
+* formatIssue(located) // '[claimant] src/core/greeting.ts:1 not assignable'
+* formatIssue(whole) // '[claimant] src/core/greeting.ts not assignable'
+* ```
+*/
+function formatIssue(issue) {
+	const where = issue.line === void 0 ? issue.path : `${issue.path}:${issue.line}`;
+	return `[${issue.origin}] ${where} ${issue.message}`;
+}
+/**
+* Renders one stage's outcome as its summary line followed by every message it reported.
+*
+* @remarks
+* A clean stage renders one line. The count appears even when it is zero, because that line is
+* what shows a reader the stage ran; a silent stage and a skipped stage read the same.
+*
+* @param check - The stage outcome to render
+* @returns The summary line, then one indented line per issue
+*
+* @example
+* ```ts
+* formatCheck({ stage: 'lint', elapsed: 17, issues: [] })
+* // 'lint: 0 issues (17 ms)'
+* ```
+*/
+function formatCheck(check) {
+	const count = check.issues.length;
+	const noun = count === 1 ? "issue" : "issues";
+	return [`${check.stage}: ${count} ${noun} (${check.elapsed} ms)`, ...check.issues.map((issue) => `  ${formatIssue(issue)}`)].join("\n");
+}
+/**
+* Renders a whole verdict as the text an agent reads.
+*
+* @remarks
+* Every stage appears for both the case and the control, so no failing stage can be masked by an
+* earlier one. The closing line always states the receipt or its absence, so a reader never has to
+* infer from silence whether the claim was proven.
+*
+* The heading lines carry everything the receipt binds, each in the name-then-value form the
+* toolchain line established: the call's identity, the claim it answered, the tools that ran, and
+* the project that judged the candidates. A verdict carrying the control's reason renders it next,
+* before either phase's checks. A reader comparing two verdicts therefore reads what differed
+* without recomputing anything.
+*
+* @param verdict - The verdict to render
+* @returns The identity, claim, toolchain, project, and reason when present, then every case and
+* control stage, then the receipt line
+*
+* @example
+* ```ts
+* formatVerdict(verdict).split('\n')[1] // 'claim 6ca20c3bff623031d3955b9d1a76d71d'
+* ```
+*/
+function formatVerdict(verdict) {
+	const { typescript, oxlint, vitest } = verdict.toolchain;
+	const tools = `toolchain typescript ${typescript}, oxlint ${oxlint}, vitest ${vitest}`;
+	const project = `project ${verdict.project.path} ${verdict.project.digest}`;
+	const reason = verdict.reason === void 0 ? [] : [`reason ${verdict.reason}`];
+	const proof = verdict.receipt === void 0 ? "no receipt" : `receipt ${verdict.receipt}`;
+	return [
+		`probe ${verdict.id} (${verdict.elapsed} ms)`,
+		`claim ${verdict.digest}`,
+		tools,
+		project,
+		...reason,
+		...verdict.case.map((check) => `case ${formatCheck(check)}`),
+		...verdict.control.map((check) => `control ${formatCheck(check)}`),
+		proof
+	].join("\n");
+}
+/**
+* Computes the proof token a verdict carries, or returns nothing when the claim was not proven.
+*
+* @remarks
+* A receipt is minted on these conditions together: both phases report one check per stage, the
+* case carries no issue, the control carries at least one `origin: 'claimant'` issue
+* at the stage it declared, and every other control stage carries no claimant issue. A control
+* that fails somewhere else has falsified the instrument rather than the claim, so no receipt is
+* minted for it.
+*
+* Both phases owe every stage, not the case alone. `stayed` reads the control entries a verdict
+* carries, so a control that omits a stage entirely would otherwise read as a stage that stayed
+* clean, and the receipt would certify an inspection that never ran. `prove` records every stage
+* for both phases, so this condition refuses only a verdict a caller assembled by hand.
+*
+* The token names every condition the verdict was reached under, so a receipt read away from its
+* verdict still says what was judged and what judged it: the claim's digest, the stage the control
+* broke at, the tool versions, and the project the candidate drafts were checked against.
+* The call's identity is deliberately absent. It carries no integrity and it is the only value
+* stopping two honest runs of one claim from producing one comparable string, so leaving it out is
+* what makes "re-run `prove` and compare tokens" a verification a reader can perform.
+*
+* The project goes last, and its own path and digest are joined by `@`. Split the token on
+* `RECEIPT_SEPARATOR`, take fields 0 through 5, and rejoin the remainder with that separator to
+* read the project field; inside it the digest is everything after the final `@`. That rule stays
+* total for a workspace-relative project path containing either character.
+*
+* An `origin: 'instrument'` issue in either phase means the inspection did not complete and
+* refuses the receipt. A workspace issue in the control does not decide whether the claimant's
+* candidate broke, while one in the case still means that the case did not run clean.
+*
+* @param verdict - The verdict whose case and control checks decide the outcome
+* @param stage - The stage the claim's control declared it must fail at
+* @returns The receipt token, or `undefined` when any condition fails
+*
+* @example
+* ```ts
+* computeReceipt(proven, 'type')
+* // 'probe:6ca20c3bff623031d3955b9d1a76d71d:type:typescript@6.0.3:oxlint@1.79.0:vitest@4.1.11:configs/src/tsconfig.core.json@3b674fdf121c85efb9ed1bab25ceeec8'
+* computeReceipt(proven, 'lint') // undefined
+* ```
+*/
+function computeReceipt(verdict, stage) {
+	const ran = PROBE_STAGES.every((name) => verdict.case.filter((check) => check.stage === name).length === 1 && verdict.control.filter((check) => check.stage === name).length === 1);
+	const clean = verdict.case.every((check) => check.issues.length === 0);
+	const broke = verdict.control.find((check) => check.stage === stage)?.issues.some((issue) => issue.origin === "claimant") ?? false;
+	const faulted = verdict.case.some((check) => check.issues.some((issue) => issue.origin === "instrument")) || verdict.control.some((check) => check.issues.some((issue) => issue.origin === "instrument"));
+	const stayed = verdict.control.every((check) => check.stage === stage || check.issues.every((issue) => issue.origin !== "claimant"));
+	if (!ran || !clean || !broke || faulted || !stayed) return void 0;
+	const { typescript, oxlint, vitest } = verdict.toolchain;
+	return [
+		RECEIPT_PREFIX,
+		verdict.digest,
+		stage,
+		`typescript@${typescript}`,
+		`oxlint@${oxlint}`,
+		`vitest@${vitest}`,
+		`${verdict.project.path}@${verdict.project.digest}`
+	].join(":");
+}
+/**
+* Renders one generated specification: the caller's own test text, then the marker naming the
+* revision that wrote it.
+*
+* @remarks
+* The marker is what makes a file in a target workspace attributable to this package. A generated
+* specification carries text the caller supplied, so its name alone cannot separate it from a
+* developer's own file, and a sweep reading the name alone deletes that file. The marker goes last
+* so every line of the caller's text keeps the number a reported stack frame gives it, and the text
+* gains a terminating newline first so the marker is never appended to a line of the test.
+*
+* @param text - The caller's own test text
+* @param revision - The writing host's process id and a fresh UUID, joined by `-`
+* @returns The bytes the runtime stage writes for that revision
+*
+* @example
+* ```ts
+* formatSpecification("test('greets', () => {})\n", '4821-9f0c')
+* // "test('greets', () => {})\n// @orkestrel/probe generated specification 4821-9f0c\n"
+* ```
+*/
+function formatSpecification(text, revision) {
+	return `${text === "" || text.endsWith("\n") ? text : `${text}\n`}// @orkestrel/probe generated specification ${revision}\n`;
+}
+/**
+* Checks whether one file's text is the generated specification written for one revision.
+*
+* @remarks
+* Reads the marker `formatSpecification` writes, taken from that function rather than restated, so
+* the writer and the reader cannot drift apart. An empty body renders the marker alone, which is
+* why the comparison is built from a call rather than from a second copy of the text.
+*
+* @param text - The file's full contents
+* @param revision - The revision the file's name declares
+* @returns True if the text ends with this package's marker for that revision; false otherwise
+*
+* @example
+* ```ts
+* matchesSpecification(formatSpecification('', '4821-9f0c'), '4821-9f0c') // true
+* matchesSpecification('export const NOTE = 1\n', '4821-9f0c') // false
+* ```
+*/
+function matchesSpecification(text, revision) {
+	return text.endsWith(formatSpecification("", revision));
+}
+//#endregion
+//#region src/core/shapers.ts
+/**
+* Describes one proposed file a claim carries.
+*
+* @remarks
+* `path` is constrained to a non-empty string because every stage resolves a file by it, so an
+* empty path names no file. That minimum is the whole of the constraint here, and it is the one
+* place the wire contract is wider than what this package admits: `isDraft` enforces the same
+* minimum and also refuses an absolute path and one that traverses out of the workspace, which no
+* JSON Schema keyword can express. A caller that satisfies this shape can still be refused, and
+* `ProbeServer` names the member when it is.
+*
+* @example
+* ```ts
+* compileGuard(DRAFT_SHAPE)({ path: 'src/core/greeting.ts', text: '' }) // true
+* ```
+*/
+var DRAFT_SHAPE = objectShape({
+	path: stringShape({
+		min: 1,
+		description: "Workspace-relative path, which need not exist."
+	}),
+	text: stringShape({ description: "The file's full contents." })
+}, { description: "One proposed file a claim carries." });
+/**
+* Describes the drafts a claim asserts about and the test that exercises them.
+*
+* @example
+* ```ts
+* const test = { path: 'tests/src/core/greeting.test.ts', text: '' }
+* compileGuard(CASE_SHAPE)({ files: [], test }) // true
+* ```
+*/
+var CASE_SHAPE = objectShape({
+	files: arrayShape(DRAFT_SHAPE, { description: "The candidate drafts the test imports." }),
+	test: DRAFT_SHAPE
+}, { description: "The drafts a claim asserts about, and the test that exercises them." });
+/**
+* Describes the negative control, which is a case plus where and why it must break.
+*
+* @remarks
+* Built from `CASE_SHAPE`'s own properties rather than a second copy of them, so the control and
+* the case cannot describe a draft differently.
+*
+* @example
+* ```ts
+* const test = { path: 'tests/src/core/greeting.test.ts', text: '' }
+* compileGuard(CONTROL_SHAPE)({ files: [], test, stage: 'type', reason: 'must not compile' }) // true
+* ```
+*/
+var CONTROL_SHAPE = objectShape({
+	...CASE_SHAPE.properties,
+	stage: literalShape(PROBE_STAGES, { description: "The stage this control must fail at." }),
+	reason: stringShape({
+		min: 1,
+		description: "Why the control fails at that stage."
+	})
+}, { description: "A case that must fail, naming the stage where it must fail and why." });
+/**
+* Describes one claim and is the sole source of both the published tool schema and the guard
+* applied to an arriving claim.
+*
+* @remarks
+* The Model Context Protocol tool publishes `compileSchema(CLAIM_SHAPE)` and admits a call with
+* `isClaim`. Deriving the advertised schema from this one value is what stops the two from drifting
+* apart across a release on any member either can express. `isClaim` is narrower on the one member
+* neither a schema keyword nor this shape can carry — the containment rule on `Draft.path` — and
+* `validators.ts` names where.
+*
+* @example
+* ```ts
+* const schema = compileSchema(CLAIM_SHAPE)
+* const admits = compileGuard(CLAIM_SHAPE)
+* schema.type // 'object'
+* admits({ project: 'tsconfig.json' }) // false
+* ```
+*/
+var CLAIM_SHAPE = objectShape({
+	project: stringShape({
+		min: 1,
+		description: "Workspace-relative TypeScript project the candidate drafts are checked against."
+	}),
+	case: CASE_SHAPE,
+	control: CONTROL_SHAPE
+}, { description: "One claim: the project, the case, and the control that must break." });
+//#endregion
+export { CASE_SHAPE, CLAIM_SHAPE, CONTROL_SHAPE, DRAFT_SHAPE, PROBE_ERROR_CODES, PROBE_PARTIES, PROBE_STAGES, ProbeError, RECEIPT_PREFIX, RECEIPT_SEPARATOR, computeReceipt, createDestroyedError, formatCheck, formatIssue, formatSpecification, formatVerdict, isCase, isCheck, isClaim, isControl, isDraft, isIssue, isParty, isProbeError, isProject, isStage, isToolchain, isVerdict, matchesSpecification };
+
+//# sourceMappingURL=index.js.map