ruflo-graph-intelligence 0.1.0-alpha.1

package/dist/domain/federation-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-protocol.d.ts","sourceRoot":"","sources":["../../src/domain/federation-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,uBAAuB;;IAElC,kCAAkC;;IAElC,iCAAiC;;IAEjC,qEAAqE;;;;;IAKrE;uDACmD;;IAEnD,+DAA+D;;;;;;;;;;;;;;;;;;;;;;EAE/D,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,eAAO,MAAM,wBAAwB;;IAEnC,kCAAkC;;IAElC,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,sEAAsE;AACtE,eAAO,MAAM,qBAAqB;;;;IAIhC,kCAAkC;;IAElC,0CAA0C;;IAE1C,0EAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM1E,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,qBAAqB;;;;IAIhC,8EAA8E;;IAE9E,0CAA0C;;;;;;;;;;;;;;EAE1C,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,uBAAuB;;IA3DlC,kCAAkC;;IAElC,iCAAiC;;IAEjC,qEAAqE;;;;;IAKrE;uDACmD;;IAEnD,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;IAW/D,kCAAkC;;IAElC,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUnC,kCAAkC;;IAElC,0CAA0C;;IAE1C,0EAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAa1E,8EAA8E;;IAE9E,0CAA0C;;;;;;;;;;;;;;IAU1C,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC5F,qCAAqC;IACrC,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC;CAC/F"}

package/dist/domain/federation-protocol.js

@@ -0,0 +1,72 @@
+/**
+ * Federation Protocol for PR Artifacts (Phase 8 — beyond-SOTA, ADR-123)
+ *
+ * Wire message types over the ADR-104 federation transport. Peers can ask
+ * for a precomputed signed PageRank vector instead of re-walking the graph,
+ * verify via the Phase 7 signer, and fall back to local recompute when the
+ * artifact is stale (graphHash mismatch) or the holder isn't trusted.
+ */
+import { z } from 'zod';
+import { SignedPageRankEnvelopeSchema } from './signed-artifact.js';
+// ============================================================================
+// Request types
+// ============================================================================
+export const PrArtifactRequestSchema = z.object({
+    type: z.literal('pr_artifact_request'),
+    /** Requesting installation id. */
+    fromInstallation: z.string().min(1),
+    /** Adapter graph id to query. */
+    graphId: z.string().min(1),
+    /** Query node for single-entry PR. Omit for full-vector requests. */
+    queryNode: z.string().optional(),
+    alpha: z.number().positive().lt(1).default(0.85),
+    epsilon: z.number().positive().default(1e-3),
+    seedNodes: z.array(z.string()).default([]),
+    /** Hash of the graph the requester has locally. Holder uses this to decide
+     *  whether to ship a fresh artifact or a delta. */
+    lastKnownGraphHash: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    /** Hash of any previous PR result the requester has cached. */
+    lastKnownResultHash: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+});
+// ============================================================================
+// Response types — either a full artifact, a delta, or a stale-rejection
+// ============================================================================
+export const PrArtifactResponseSchema = z.object({
+    type: z.literal('pr_artifact_response'),
+    /** Responding installation id. */
+    fromInstallation: z.string().min(1),
+    /** The Phase 7 signed envelope. */
+    envelope: SignedPageRankEnvelopeSchema,
+});
+/** Lightweight delta — only the score difference + new resultHash. */
+export const PrArtifactDeltaSchema = z.object({
+    type: z.literal('pr_artifact_delta'),
+    fromInstallation: z.string().min(1),
+    graphId: z.string().min(1),
+    /** Hash the delta is based on. */
+    baseResultHash: z.string().regex(/^[0-9a-f]{64}$/),
+    /** New resultHash after delta applied. */
+    newResultHash: z.string().regex(/^[0-9a-f]{64}$/),
+    /** Score delta (single-entry) or sparse delta indices+values (vector). */
+    scoreDelta: z.number().optional(),
+    sparseDelta: z.object({
+        indices: z.array(z.number().int().nonnegative()),
+        values: z.array(z.number()),
+    }).optional(),
+});
+export const PrArtifactStaleSchema = z.object({
+    type: z.literal('pr_artifact_stale'),
+    fromInstallation: z.string().min(1),
+    graphId: z.string().min(1),
+    /** The holder's current graph hash so the requester can decide what to do. */
+    currentGraphHash: z.string().regex(/^[0-9a-f]{64}$/),
+    /** Why the request was stale-rejected. */
+    reason: z.string(),
+});
+export const FederationMessageSchema = z.discriminatedUnion('type', [
+    PrArtifactRequestSchema,
+    PrArtifactResponseSchema,
+    PrArtifactDeltaSchema,
+    PrArtifactStaleSchema,
+]);
+//# sourceMappingURL=federation-protocol.js.map

package/dist/domain/federation-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-protocol.js","sourceRoot":"","sources":["../../src/domain/federation-protocol.ts"],"names":[],"mappings":"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"}

package/dist/domain/signed-artifact.d.ts

@@ -0,0 +1,429 @@
+/**
+ * Signed PageRank Artifact (Phase 7 — beyond-SOTA, ADR-123)
+ *
+ * RuFlo gains a primitive no competing memory framework can ship: a portable,
+ * Ed25519-signed PageRank result that carries enough metadata for a remote
+ * peer to verify provenance + budget compliance + input stability without
+ * trusting the producer. Federation peers exchange these instead of
+ * re-walking graphs.
+ *
+ * Schema mirrors the ADR-123 Architecture diagram with the upstream 1.7.0
+ * additions: `complexity_class` (budget compliance) + `coherence_score`
+ * (DD-margin at compute time).
+ */
+import { z } from 'zod';
+import { type PageRankResult } from './types.js';
+export declare const ARTIFACT_ENVELOPE_VERSION = "1.0.0";
+export declare const ARTIFACT_ENVELOPE_KIND = "pagerank";
+export declare const SignedPageRankPayloadSchema: z.ZodObject<{
+    envelopeVersion: z.ZodLiteral<"1.0.0">;
+    kind: z.ZodLiteral<"pagerank">;
+    installationId: z.ZodString;
+    /** Witness key ID (key version, not key identity per ADR-103). */
+    witnessKeyId: z.ZodString;
+    /** Ed25519 public key (hex, 32 bytes). */
+    publicKey: z.ZodString;
+    /** Adapter graph id (e.g. `ruflo-federation:trust-mesh`). */
+    graphId: z.ZodString;
+    /** SHA-256 of the input matrix's `contentHash`. */
+    graphHash: z.ZodString;
+    /** Wall-clock at compute time. */
+    graphTimestamp: z.ZodString;
+    algorithm: z.ZodEnum<["forward-push", "backward-push", "bidirectional", "cg", "neumann"]>;
+    alpha: z.ZodNumber;
+    epsilon: z.ZodNumber;
+    /** Query node — None for full-vector artifacts. */
+    queryNode: z.ZodOptional<z.ZodString>;
+    /** Seed nodes (PPR). Empty for plain PR. */
+    seedNodes: z.ZodArray<z.ZodString, "many">;
+    /** Result (single-entry or full-vector). */
+    result: z.ZodObject<{
+        graphId: z.ZodString;
+        nodeId: z.ZodString;
+        score: z.ZodNumber;
+        alpha: z.ZodNumber;
+        epsilon: z.ZodNumber;
+        iterations: z.ZodNumber;
+        complexityClass: z.ZodEnum<["constant", "logarithmic", "polylogarithmic", "sublinear", "linear", "linearithmic", "polynomial", "exponential", "doubleExponential", "adaptive", "unknown", "unbounded"]>;
+        coherence: z.ZodObject<{
+            score: z.ZodNumber;
+            passed: z.ZodBoolean;
+            threshold: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            passed: boolean;
+            threshold: number;
+        }, {
+            score: number;
+            passed: boolean;
+            threshold: number;
+        }>;
+        computedAt: z.ZodString;
+        resultHash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        graphId: string;
+        score: number;
+        nodeId: string;
+        alpha: number;
+        epsilon: number;
+        iterations: number;
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        coherence: {
+            score: number;
+            passed: boolean;
+            threshold: number;
+        };
+        computedAt: string;
+        resultHash: string;
+    }, {
+        graphId: string;
+        score: number;
+        nodeId: string;
+        alpha: number;
+        epsilon: number;
+        iterations: number;
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        coherence: {
+            score: number;
+            passed: boolean;
+            threshold: number;
+        };
+        computedAt: string;
+        resultHash: string;
+    }>;
+    /** Class the solver actually achieved (echoes result.complexityClass). */
+    complexityClass: z.ZodEnum<["constant", "logarithmic", "polylogarithmic", "sublinear", "linear", "linearithmic", "polynomial", "exponential", "doubleExponential", "adaptive", "unknown", "unbounded"]>;
+    /** Coherence margin at compute time (echoes result.coherence.score). */
+    coherenceScore: z.ZodNumber;
+    /** Hash of `result` (echoes result.resultHash). */
+    resultHash: z.ZodString;
+    /** When the envelope was sealed. */
+    sealedAt: z.ZodString;
+    /** Solver version used. */
+    solverVersion: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    graphId: string;
+    alpha: number;
+    epsilon: number;
+    seedNodes: string[];
+    complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+    resultHash: string;
+    algorithm: "cg" | "neumann" | "forward-push" | "backward-push" | "bidirectional";
+    result: {
+        graphId: string;
+        score: number;
+        nodeId: string;
+        alpha: number;
+        epsilon: number;
+        iterations: number;
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        coherence: {
+            score: number;
+            passed: boolean;
+            threshold: number;
+        };
+        computedAt: string;
+        resultHash: string;
+    };
+    envelopeVersion: "1.0.0";
+    kind: "pagerank";
+    installationId: string;
+    witnessKeyId: string;
+    publicKey: string;
+    graphHash: string;
+    graphTimestamp: string;
+    coherenceScore: number;
+    sealedAt: string;
+    solverVersion: string;
+    queryNode?: string | undefined;
+}, {
+    graphId: string;
+    alpha: number;
+    epsilon: number;
+    seedNodes: string[];
+    complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+    resultHash: string;
+    algorithm: "cg" | "neumann" | "forward-push" | "backward-push" | "bidirectional";
+    result: {
+        graphId: string;
+        score: number;
+        nodeId: string;
+        alpha: number;
+        epsilon: number;
+        iterations: number;
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        coherence: {
+            score: number;
+            passed: boolean;
+            threshold: number;
+        };
+        computedAt: string;
+        resultHash: string;
+    };
+    envelopeVersion: "1.0.0";
+    kind: "pagerank";
+    installationId: string;
+    witnessKeyId: string;
+    publicKey: string;
+    graphHash: string;
+    graphTimestamp: string;
+    coherenceScore: number;
+    sealedAt: string;
+    queryNode?: string | undefined;
+    solverVersion?: string | undefined;
+}>;
+export type SignedPageRankPayload = z.infer<typeof SignedPageRankPayloadSchema>;
+export declare const SignedPageRankEnvelopeSchema: z.ZodObject<{
+    payload: z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<"1.0.0">;
+        kind: z.ZodLiteral<"pagerank">;
+        installationId: z.ZodString;
+        /** Witness key ID (key version, not key identity per ADR-103). */
+        witnessKeyId: z.ZodString;
+        /** Ed25519 public key (hex, 32 bytes). */
+        publicKey: z.ZodString;
+        /** Adapter graph id (e.g. `ruflo-federation:trust-mesh`). */
+        graphId: z.ZodString;
+        /** SHA-256 of the input matrix's `contentHash`. */
+        graphHash: z.ZodString;
+        /** Wall-clock at compute time. */
+        graphTimestamp: z.ZodString;
+        algorithm: z.ZodEnum<["forward-push", "backward-push", "bidirectional", "cg", "neumann"]>;
+        alpha: z.ZodNumber;
+        epsilon: z.ZodNumber;
+        /** Query node — None for full-vector artifacts. */
+        queryNode: z.ZodOptional<z.ZodString>;
+        /** Seed nodes (PPR). Empty for plain PR. */
+        seedNodes: z.ZodArray<z.ZodString, "many">;
+        /** Result (single-entry or full-vector). */
+        result: z.ZodObject<{
+            graphId: z.ZodString;
+            nodeId: z.ZodString;
+            score: z.ZodNumber;
+            alpha: z.ZodNumber;
+            epsilon: z.ZodNumber;
+            iterations: z.ZodNumber;
+            complexityClass: z.ZodEnum<["constant", "logarithmic", "polylogarithmic", "sublinear", "linear", "linearithmic", "polynomial", "exponential", "doubleExponential", "adaptive", "unknown", "unbounded"]>;
+            coherence: z.ZodObject<{
+                score: z.ZodNumber;
+                passed: z.ZodBoolean;
+                threshold: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            }, {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            }>;
+            computedAt: z.ZodString;
+            resultHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            graphId: string;
+            score: number;
+            nodeId: string;
+            alpha: number;
+            epsilon: number;
+            iterations: number;
+            complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+            coherence: {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            };
+            computedAt: string;
+            resultHash: string;
+        }, {
+            graphId: string;
+            score: number;
+            nodeId: string;
+            alpha: number;
+            epsilon: number;
+            iterations: number;
+            complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+            coherence: {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            };
+            computedAt: string;
+            resultHash: string;
+        }>;
+        /** Class the solver actually achieved (echoes result.complexityClass). */
+        complexityClass: z.ZodEnum<["constant", "logarithmic", "polylogarithmic", "sublinear", "linear", "linearithmic", "polynomial", "exponential", "doubleExponential", "adaptive", "unknown", "unbounded"]>;
+        /** Coherence margin at compute time (echoes result.coherence.score). */
+        coherenceScore: z.ZodNumber;
+        /** Hash of `result` (echoes result.resultHash). */
+        resultHash: z.ZodString;
+        /** When the envelope was sealed. */
+        sealedAt: z.ZodString;
+        /** Solver version used. */
+        solverVersion: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        graphId: string;
+        alpha: number;
+        epsilon: number;
+        seedNodes: string[];
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        resultHash: string;
+        algorithm: "cg" | "neumann" | "forward-push" | "backward-push" | "bidirectional";
+        result: {
+            graphId: string;
+            score: number;
+            nodeId: string;
+            alpha: number;
+            epsilon: number;
+            iterations: number;
+            complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+            coherence: {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            };
+            computedAt: string;
+            resultHash: string;
+        };
+        envelopeVersion: "1.0.0";
+        kind: "pagerank";
+        installationId: string;
+        witnessKeyId: string;
+        publicKey: string;
+        graphHash: string;
+        graphTimestamp: string;
+        coherenceScore: number;
+        sealedAt: string;
+        solverVersion: string;
+        queryNode?: string | undefined;
+    }, {
+        graphId: string;
+        alpha: number;
+        epsilon: number;
+        seedNodes: string[];
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        resultHash: string;
+        algorithm: "cg" | "neumann" | "forward-push" | "backward-push" | "bidirectional";
+        result: {
+            graphId: string;
+            score: number;
+            nodeId: string;
+            alpha: number;
+            epsilon: number;
+            iterations: number;
+            complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+            coherence: {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            };
+            computedAt: string;
+            resultHash: string;
+        };
+        envelopeVersion: "1.0.0";
+        kind: "pagerank";
+        installationId: string;
+        witnessKeyId: string;
+        publicKey: string;
+        graphHash: string;
+        graphTimestamp: string;
+        coherenceScore: number;
+        sealedAt: string;
+        queryNode?: string | undefined;
+        solverVersion?: string | undefined;
+    }>;
+    signature: z.ZodString;
+    algorithm: z.ZodLiteral<"ed25519">;
+}, "strip", z.ZodTypeAny, {
+    algorithm: "ed25519";
+    payload: {
+        graphId: string;
+        alpha: number;
+        epsilon: number;
+        seedNodes: string[];
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        resultHash: string;
+        algorithm: "cg" | "neumann" | "forward-push" | "backward-push" | "bidirectional";
+        result: {
+            graphId: string;
+            score: number;
+            nodeId: string;
+            alpha: number;
+            epsilon: number;
+            iterations: number;
+            complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+            coherence: {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            };
+            computedAt: string;
+            resultHash: string;
+        };
+        envelopeVersion: "1.0.0";
+        kind: "pagerank";
+        installationId: string;
+        witnessKeyId: string;
+        publicKey: string;
+        graphHash: string;
+        graphTimestamp: string;
+        coherenceScore: number;
+        sealedAt: string;
+        solverVersion: string;
+        queryNode?: string | undefined;
+    };
+    signature: string;
+}, {
+    algorithm: "ed25519";
+    payload: {
+        graphId: string;
+        alpha: number;
+        epsilon: number;
+        seedNodes: string[];
+        complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+        resultHash: string;
+        algorithm: "cg" | "neumann" | "forward-push" | "backward-push" | "bidirectional";
+        result: {
+            graphId: string;
+            score: number;
+            nodeId: string;
+            alpha: number;
+            epsilon: number;
+            iterations: number;
+            complexityClass: "unknown" | "constant" | "logarithmic" | "polylogarithmic" | "sublinear" | "linear" | "linearithmic" | "polynomial" | "exponential" | "doubleExponential" | "adaptive" | "unbounded";
+            coherence: {
+                score: number;
+                passed: boolean;
+                threshold: number;
+            };
+            computedAt: string;
+            resultHash: string;
+        };
+        envelopeVersion: "1.0.0";
+        kind: "pagerank";
+        installationId: string;
+        witnessKeyId: string;
+        publicKey: string;
+        graphHash: string;
+        graphTimestamp: string;
+        coherenceScore: number;
+        sealedAt: string;
+        queryNode?: string | undefined;
+        solverVersion?: string | undefined;
+    };
+    signature: string;
+}>;
+export type SignedPageRankEnvelope = z.infer<typeof SignedPageRankEnvelopeSchema>;
+export interface ArtifactVerificationResult {
+    valid: boolean;
+    signatureValid: boolean;
+    schemaValid: boolean;
+    /** True iff graphHash + resultHash + signature all check out. */
+    integrityValid: boolean;
+    publicKey?: string;
+    /** Complexity class echo — callers can budget against this. */
+    complexityClass?: PageRankResult['complexityClass'];
+    /** Coherence margin echo — callers can sanity-check input stability. */
+    coherenceScore?: number;
+    reason?: string;
+}
+//# sourceMappingURL=signed-artifact.d.ts.map

package/dist/domain/signed-artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-artifact.d.ts","sourceRoot":"","sources":["../../src/domain/signed-artifact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,yBAAyB,UAAU,CAAC;AACjD,eAAO,MAAM,sBAAsB,aAAa,CAAC;AAEjD,eAAO,MAAM,2BAA2B;;;;IAItC,kEAAkE;;IAElE,0CAA0C;;IAE1C,6DAA6D;;IAE7D,mDAAmD;;IAEnD,kCAAkC;;;;;IAKlC,mDAAmD;;IAEnD,4CAA4C;;IAE5C,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE5C,0EAA0E;;IAE1E,wEAAwE;;IAExE,mDAAmD;;IAEnD,oCAAoC;;IAEpC,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3B,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,4BAA4B;;;;;QAhCvC,kEAAkE;;QAElE,0CAA0C;;QAE1C,6DAA6D;;QAE7D,mDAAmD;;QAEnD,kCAAkC;;;;;QAKlC,mDAAmD;;QAEnD,4CAA4C;;QAE5C,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAE5C,0EAA0E;;QAE1E,wEAAwE;;QAExE,mDAAmD;;QAEnD,oCAAoC;;QAEpC,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,OAAO,CAAC;IACrB,iEAAiE;IACjE,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC;IACpD,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/domain/signed-artifact.js

@@ -0,0 +1,57 @@
+/**
+ * Signed PageRank Artifact (Phase 7 — beyond-SOTA, ADR-123)
+ *
+ * RuFlo gains a primitive no competing memory framework can ship: a portable,
+ * Ed25519-signed PageRank result that carries enough metadata for a remote
+ * peer to verify provenance + budget compliance + input stability without
+ * trusting the producer. Federation peers exchange these instead of
+ * re-walking graphs.
+ *
+ * Schema mirrors the ADR-123 Architecture diagram with the upstream 1.7.0
+ * additions: `complexity_class` (budget compliance) + `coherence_score`
+ * (DD-margin at compute time).
+ */
+import { z } from 'zod';
+import { ComplexityClassSchema, PageRankResultSchema, } from './types.js';
+export const ARTIFACT_ENVELOPE_VERSION = '1.0.0';
+export const ARTIFACT_ENVELOPE_KIND = 'pagerank';
+export const SignedPageRankPayloadSchema = z.object({
+    envelopeVersion: z.literal(ARTIFACT_ENVELOPE_VERSION),
+    kind: z.literal(ARTIFACT_ENVELOPE_KIND),
+    installationId: z.string().min(1),
+    /** Witness key ID (key version, not key identity per ADR-103). */
+    witnessKeyId: z.string().min(1),
+    /** Ed25519 public key (hex, 32 bytes). */
+    publicKey: z.string().regex(/^[0-9a-f]{64}$/),
+    /** Adapter graph id (e.g. `ruflo-federation:trust-mesh`). */
+    graphId: z.string().min(1),
+    /** SHA-256 of the input matrix's `contentHash`. */
+    graphHash: z.string().regex(/^[0-9a-f]{64}$/),
+    /** Wall-clock at compute time. */
+    graphTimestamp: z.string(),
+    algorithm: z.enum(['forward-push', 'backward-push', 'bidirectional', 'cg', 'neumann']),
+    alpha: z.number().positive().lt(1),
+    epsilon: z.number().positive(),
+    /** Query node — None for full-vector artifacts. */
+    queryNode: z.string().optional(),
+    /** Seed nodes (PPR). Empty for plain PR. */
+    seedNodes: z.array(z.string()),
+    /** Result (single-entry or full-vector). */
+    result: PageRankResultSchema,
+    /** Class the solver actually achieved (echoes result.complexityClass). */
+    complexityClass: ComplexityClassSchema,
+    /** Coherence margin at compute time (echoes result.coherence.score). */
+    coherenceScore: z.number(),
+    /** Hash of `result` (echoes result.resultHash). */
+    resultHash: z.string().regex(/^[0-9a-f]{64}$/),
+    /** When the envelope was sealed. */
+    sealedAt: z.string(),
+    /** Solver version used. */
+    solverVersion: z.string().default('sublinear-time-solver@1.7.0'),
+});
+export const SignedPageRankEnvelopeSchema = z.object({
+    payload: SignedPageRankPayloadSchema,
+    signature: z.string().regex(/^[0-9a-f]{128}$/),
+    algorithm: z.literal('ed25519'),
+});
+//# sourceMappingURL=signed-artifact.js.map

package/dist/domain/signed-artifact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-artifact.js","sourceRoot":"","sources":["../../src/domain/signed-artifact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GAErB,MAAM,YAAY,CAAC;AAEpB,MAAM,CAAC,MAAM,yBAAyB,GAAG,OAAO,CAAC;AACjD,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;AAEjD,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,yBAAyB,CAAC;IACrD,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,sBAAsB,CAAC;IACvC,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,kEAAkE;IAClE,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,0CAA0C;IAC1C,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC;IAC7C,6DAA6D;IAC7D,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,mDAAmD;IACnD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC;IAC7C,kCAAkC;IAClC,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;IAC1B,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;IACtF,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAClC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,mDAAmD;IACnD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,4CAA4C;IAC5C,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9B,4CAA4C;IAC5C,MAAM,EAAE,oBAAoB;IAC5B,0EAA0E;IAC1E,eAAe,EAAE,qBAAqB;IACtC,wEAAwE;IACxE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;IAC1B,mDAAmD;IACnD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC;IAC9C,oCAAoC;IACpC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,2BAA2B;IAC3B,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,6BAA6B,CAAC;CACjE,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,OAAO,EAAE,2BAA2B;IACpC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC;IAC9C,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;CAChC,CAAC,CAAC"}