@tiphys/kernel 0.0.0 → 0.2.0

package/dist/src/gates/deploy.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/gates/deploy.js

@@ -0,0 +1,33 @@
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { runReleaseGate } from "./release.js";
+/**
+ * THE DEPLOY GATE ENTRY (kernel plan M2, M2-P7 step 4). A thin entry point
+ * that names the declared `deploy` verification and calls the one contract
+ * module, `src/gates/release.ts`. The manifest keeps its two static entries
+ * exactly as section 1.4 declares them, so no gate-runner or exit-test
+ * arithmetic changes, and M2 deliberately does not generalize to N
+ * charter-declared verifications (section 2 item 12; that is M3's).
+ *
+ * Release verification is structurally NOT a pull-request gate: it runs
+ * after a merge, against a commit that exists only once the merge has
+ * happened, so a pre-merge bundle can only ever report not-applicable, on
+ * every repository (investigation section 1.3, observation O-3). The real
+ * call site is the orchestrator's post-merge step with the merged sha as
+ * `--base`, deferred to M4 by M2-D-11.
+ */
+function isMain() {
+    const argv1 = process.argv[1];
+    if (argv1 === undefined) {
+        return false;
+    }
+    try {
+        return realpathSync(argv1) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (isMain()) {
+    process.exitCode = await runReleaseGate("deploy", process.argv.slice(2));
+}

package/dist/src/gates/gate-classes.d.ts

@@ -0,0 +1,56 @@
+/** DR-0029's three required classes, in the order the record reports them. */
+declare const REQUIRED_CLASSES: readonly ["correctness", "scope", "review"];
+type RequiredClass = (typeof REQUIRED_CLASSES)[number];
+interface ClassDeclaration {
+    gates?: string[];
+    status?: string;
+    reason?: string;
+    establishedBy?: string;
+}
+type RegistryIdsResult = {
+    ok: true;
+    ids: Set<string>;
+    conditional: Set<string>;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * The legal gate ids: every entry of this repository's own registry.
+ *
+ * A failure here is `error` at the call site and never a skipped check. The
+ * registry is DECODED rather than JSON-parsed because it ships as YAML and
+ * `decodeDocument` is the delivered decoder for both (DR-0013 YAML clause 3).
+ */
+declare function registryGateIds(path: string): RegistryIdsResult;
+interface ClassVerdict {
+    name: RequiredClass;
+    ok: boolean;
+    /** One sentence, printed on either arm. */
+    sentence: string;
+    /** True when this class is satisfied by a declared escape rather than a gate. */
+    escape: boolean;
+    /**
+     * The gate ids this class names that are `applicability: conditional`.
+     *
+     * NOT A FAILURE AND NOT AN ESCAPE, which is why it is a third field rather
+     * than a reuse of either (CR-FS-GATES-01). A conditional gate is a legitimate
+     * satisfier; what a reader is owed is that it can report not-applicable at a
+     * head and that nothing here checked whether it did.
+     */
+    conditionalGates: string[];
+}
+/**
+ * Judge ONE class. Every red arm names the class, so the detail a reader sees
+ * says which of the three is wrong rather than only that something is.
+ */
+declare function judgeClass(name: RequiredClass, entry: ClassDeclaration | undefined, knownGateIds: Set<string>, conditionalGateIds?: Set<string>): ClassVerdict;
+interface CompilerReading {
+    files: string[];
+    errors: string[];
+}
+/** Split a real `tsc --listFiles` capture into its file list and its errors. */
+declare function readCompilerOutput(text: string): CompilerReading;
+export declare function main(argv: string[]): number;
+export { judgeClass, readCompilerOutput, registryGateIds, REQUIRED_CLASSES };
+export type { ClassDeclaration, ClassVerdict, RequiredClass };