@ai-sdlc/orchestrator 0.6.0 → 0.10.0

package/dist/sa-scoring/depparse-client.d.ts

@@ -0,0 +1,79 @@
+/**
+ * TypeScript client for the `sidecar-depparse` HTTP service.
+ *
+ * Used by Layer 1 deterministic SA scoring (RFC-0008 §B.4.2) to detect
+ * requirement constructions (`requires X`, `must have X`, `X required`,
+ * passive + negation-aware) in issue text.
+ *
+ * The client is injectable — production code wires in `HttpDepparseClient`
+ * pointing at the sidecar URL, tests inject a `FakeDepparseClient` to
+ * avoid the Python dependency.
+ *
+ * Retry semantics: one retry on 5xx responses (network or transient),
+ * typed failure on anything else. Fail-soft by default — caller can
+ * treat a `DepparseUnavailable` failure as "no matches" when the
+ * sidecar is optional.
+ */
+export interface DepparseMatch {
+    pattern: string;
+    matchedText: string;
+    depPath: string[];
+    construction: string;
+}
+export interface DepparseMatchRequest {
+    text: string;
+    patterns: string[];
+}
+export interface DepparseMatchResponse {
+    matches: DepparseMatch[];
+}
+export interface DepparseHealth {
+    status: string;
+    model?: string;
+    modelLoaded: boolean;
+}
+export interface DepparseClient {
+    match(request: DepparseMatchRequest): Promise<DepparseMatchResponse>;
+    healthz(): Promise<DepparseHealth>;
+}
+export type DepparseErrorKind = 'network' | 'bad-request' | 'server-error' | 'model-unavailable' | 'timeout';
+export declare class DepparseError extends Error {
+    readonly kind: DepparseErrorKind;
+    readonly status?: number;
+    constructor(kind: DepparseErrorKind, message: string, status?: number);
+}
+export interface HttpDepparseClientOptions {
+    baseUrl: string;
+    /** Per-request timeout in ms. Default 5 000. */
+    timeoutMs?: number;
+    /** Number of retries on 5xx / network errors. Default 1. */
+    retries?: number;
+    /** Injectable fetch — lets tests stub without overriding globalThis. */
+    fetchImpl?: typeof fetch;
+}
+export declare class HttpDepparseClient implements DepparseClient {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly retries;
+    private readonly fetchImpl;
+    constructor(opts: HttpDepparseClientOptions);
+    healthz(): Promise<DepparseHealth>;
+    match(request: DepparseMatchRequest): Promise<DepparseMatchResponse>;
+    private requestJson;
+    private doFetch;
+}
+/**
+ * In-memory test double that matches patterns by exact substring —
+ * sufficient for unit tests that don't care about dependency-parse
+ * semantics. Real scoring tests use recorded fixtures.
+ */
+export declare class FakeDepparseClient implements DepparseClient {
+    private responses;
+    private healthResponse;
+    callLog: DepparseMatchRequest[];
+    setResponse(response: DepparseMatchResponse): void;
+    setHealth(health: DepparseHealth): void;
+    match(request: DepparseMatchRequest): Promise<DepparseMatchResponse>;
+    healthz(): Promise<DepparseHealth>;
+}
+//# sourceMappingURL=depparse-client.d.ts.map

package/dist/sa-scoring/depparse-client.js

@@ -0,0 +1,187 @@
+/**
+ * TypeScript client for the `sidecar-depparse` HTTP service.
+ *
+ * Used by Layer 1 deterministic SA scoring (RFC-0008 §B.4.2) to detect
+ * requirement constructions (`requires X`, `must have X`, `X required`,
+ * passive + negation-aware) in issue text.
+ *
+ * The client is injectable — production code wires in `HttpDepparseClient`
+ * pointing at the sidecar URL, tests inject a `FakeDepparseClient` to
+ * avoid the Python dependency.
+ *
+ * Retry semantics: one retry on 5xx responses (network or transient),
+ * typed failure on anything else. Fail-soft by default — caller can
+ * treat a `DepparseUnavailable` failure as "no matches" when the
+ * sidecar is optional.
+ */
+export class DepparseError extends Error {
+    kind;
+    status;
+    constructor(kind, message, status) {
+        super(message);
+        this.name = 'DepparseError';
+        this.kind = kind;
+        this.status = status;
+    }
+}
+export class HttpDepparseClient {
+    baseUrl;
+    timeoutMs;
+    retries;
+    fetchImpl;
+    constructor(opts) {
+        this.baseUrl = assertHttpUrl(opts.baseUrl).replace(/\/$/, '');
+        this.timeoutMs = opts.timeoutMs ?? 5_000;
+        this.retries = opts.retries ?? 1;
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+    }
+    async healthz() {
+        const res = await this.requestJson('GET', '/healthz');
+        return {
+            status: res.status,
+            model: res.model ?? undefined,
+            modelLoaded: Boolean(res.model_loaded),
+        };
+    }
+    async match(request) {
+        const body = JSON.stringify(request);
+        const res = await this.requestJson('POST', '/v1/match', body);
+        return {
+            matches: res.matches.map((m) => ({
+                pattern: m.pattern,
+                matchedText: m.matched_text,
+                depPath: m.dep_path,
+                construction: m.construction,
+            })),
+        };
+    }
+    // ── Internals ──────────────────────────────────────────────────
+    async requestJson(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        let lastError;
+        const attempts = this.retries + 1;
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            try {
+                const res = await this.doFetch(url, method, body);
+                if (res.ok) {
+                    return (await res.json());
+                }
+                if (res.status === 503) {
+                    // Model not yet loaded — permanent for this request window.
+                    const text = await safeText(res);
+                    throw new DepparseError('model-unavailable', text || `503 at ${url}`, 503);
+                }
+                if (res.status >= 500) {
+                    lastError = new DepparseError('server-error', `${res.status} at ${url}`, res.status);
+                    continue; // retry
+                }
+                const text = await safeText(res);
+                throw new DepparseError('bad-request', text || `${res.status} at ${url}`, res.status);
+            }
+            catch (err) {
+                if (err instanceof DepparseError) {
+                    if (err.kind === 'server-error' && attempt + 1 < attempts) {
+                        lastError = err;
+                        continue;
+                    }
+                    throw err;
+                }
+                // Network / abort / unknown — retry once
+                lastError = new DepparseError(errIsAbort(err) ? 'timeout' : 'network', err instanceof Error ? err.message : String(err));
+                if (attempt + 1 >= attempts)
+                    throw lastError;
+            }
+        }
+        throw lastError ?? new DepparseError('network', `No response from ${url}`);
+    }
+    async doFetch(url, method, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            return await this.fetchImpl(url, {
+                method,
+                headers: body ? { 'content-type': 'application/json' } : undefined,
+                body,
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+async function safeText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Refuses non-HTTP schemes. Env-var or CLI-supplied `baseUrl` with
+ * `file://`, `data:`, `javascript:`, or similar could trigger local
+ * file reads or arbitrary protocol handlers when passed to `fetch()`.
+ */
+function assertHttpUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new DepparseError('bad-request', `depparse baseUrl is not a valid URL: ${url}`);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new DepparseError('bad-request', `depparse baseUrl must use http: or https: (got ${parsed.protocol})`);
+    }
+    return url;
+}
+function errIsAbort(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        'name' in err &&
+        err.name === 'AbortError');
+}
+// ── Fake client for tests ────────────────────────────────────────────
+/**
+ * In-memory test double that matches patterns by exact substring —
+ * sufficient for unit tests that don't care about dependency-parse
+ * semantics. Real scoring tests use recorded fixtures.
+ */
+export class FakeDepparseClient {
+    responses;
+    healthResponse = {
+        status: 'ok',
+        model: 'fake',
+        modelLoaded: true,
+    };
+    callLog = [];
+    setResponse(response) {
+        this.responses = response;
+    }
+    setHealth(health) {
+        this.healthResponse = health;
+    }
+    async match(request) {
+        this.callLog.push(request);
+        if (this.responses)
+            return this.responses;
+        // Fallback: return substring matches with no dep_path info.
+        const matches = [];
+        for (const pattern of request.patterns) {
+            if (request.text.toLowerCase().includes(pattern.toLowerCase())) {
+                matches.push({
+                    pattern,
+                    matchedText: pattern,
+                    depPath: [],
+                    construction: 'substring',
+                });
+            }
+        }
+        return { matches };
+    }
+    async healthz() {
+        return this.healthResponse;
+    }
+}
+//# sourceMappingURL=depparse-client.js.map

package/dist/sa-scoring/did-compiler.d.ts

@@ -0,0 +1,122 @@
+/**
+ * DID compilation pipeline (RFC-0008 Addendum B §B.3.3).
+ *
+ * Consumes a `DesignIntentDocument` and produces six deterministic
+ * artifacts consumed by the three-layer SA scorer:
+ *
+ *   1. scopeLists          — flattened in/out scope synonyms
+ *   2. constraintRules     — detection patterns per soul constraint
+ *   3. antiPatternLists    — product + per-principle + voice + visual
+ *   4. measurableSignals   — principle signals + visual constraints
+ *   5. bm25Corpus          — SA-1 corpus (mission + experientialTargets,
+ *                            core fields weighted 2×, evolving 1×)
+ *   6. principleCorpora    — one SA-2 corpus per designPrinciple
+ *
+ * The output is stable given identical input (canonical JSON + sha256
+ * hash) so `did_compiled_artifacts.source_hash` can be used to detect
+ * DID changes cheaply.
+ */
+import type { Constraint, DesignIntentDocument, IdentityClass, MeasurableOperator } from '@ai-sdlc/reference';
+export interface CompiledScopeEntry {
+    label: string;
+    synonyms: string[];
+    identityClass: IdentityClass;
+}
+export interface CompiledScopeLists {
+    inScope: CompiledScopeEntry[];
+    outOfScope: CompiledScopeEntry[];
+}
+export interface CompiledConstraintRule {
+    id: string;
+    concept: string;
+    relationship: Constraint['relationship'];
+    detectionPatterns: string[];
+    identityClass: IdentityClass;
+}
+export interface CompiledAntiPattern {
+    id: string;
+    label: string;
+    detectionPatterns: string[];
+    identityClass: IdentityClass;
+}
+export interface CompiledAntiPatternLists {
+    product: CompiledAntiPattern[];
+    /** Keyed by `designPrinciple.id`. */
+    perPrinciple: Record<string, CompiledAntiPattern[]>;
+    voice: CompiledAntiPattern[];
+    visual: CompiledAntiPattern[];
+}
+export interface CompiledMeasurableSignal {
+    id: string;
+    metric: string;
+    threshold: number;
+    operator: MeasurableOperator;
+    scope?: string;
+    /** Present when derived from a specific principle's signals list. */
+    sourcePrinciple?: string;
+    /** Present when derived from a visual constraint rule. */
+    sourceVisual?: string;
+    identityClass: IdentityClass;
+}
+export interface Bm25Document {
+    id: string;
+    tokens: string[];
+    /** 2 when derived from `identityClass: 'core'`, else 1. */
+    weight: number;
+}
+export interface Bm25Corpus {
+    documents: Bm25Document[];
+}
+export type PrincipleCorpora = Record<string, Bm25Corpus>;
+export interface CompiledDid {
+    didName: string;
+    namespace?: string;
+    sourceHash: string;
+    scopeLists: CompiledScopeLists;
+    constraintRules: CompiledConstraintRule[];
+    antiPatternLists: CompiledAntiPatternLists;
+    measurableSignals: CompiledMeasurableSignal[];
+    bm25Corpus: Bm25Corpus;
+    principleCorpora: PrincipleCorpora;
+}
+export declare function tokenize(text: string): string[];
+/**
+ * Stable JSON: keys sorted alphabetically at every depth. Matches the
+ * Python json.dumps(sort_keys=True) output so cross-language consumers
+ * agree on the source hash.
+ */
+export declare function canonicalJson(value: unknown): string;
+export declare function hashDidSpec(did: DesignIntentDocument): string;
+export declare function compileDid(did: DesignIntentDocument): CompiledDid;
+export interface ReadinessResult {
+    ready: boolean;
+    gaps: string[];
+}
+/**
+ * Enforce the §B.10.2 minimums a DID must meet before Phase-2b scoring
+ * is safe to enable. Returns a list of gaps; empty ⇒ ready.
+ */
+export declare function validatePhase2bReadiness(compiled: CompiledDid): ReadinessResult;
+export declare function serializeForStore(compiled: CompiledDid): {
+    didName: string;
+    namespace?: string;
+    sourceHash: string;
+    scopeListsJson: string;
+    constraintRulesJson: string;
+    antiPatternListsJson: string;
+    measurableSignalsJson: string;
+    bm25CorpusBlob: Buffer;
+    principleCorporaBlob: Buffer;
+};
+export declare function deserializeFromStore(record: {
+    didName: string;
+    namespace?: string;
+    sourceHash: string;
+    scopeListsJson?: string;
+    constraintRulesJson?: string;
+    antiPatternListsJson?: string;
+    measurableSignalsJson?: string;
+    bm25CorpusBlob?: Buffer;
+    principleCorporaBlob?: Buffer;
+}): CompiledDid;
+//# sourceMappingURL=did-compiler.d.ts.map

package/dist/sa-scoring/did-compiler.js

@@ -0,0 +1,286 @@
+/**
+ * DID compilation pipeline (RFC-0008 Addendum B §B.3.3).
+ *
+ * Consumes a `DesignIntentDocument` and produces six deterministic
+ * artifacts consumed by the three-layer SA scorer:
+ *
+ *   1. scopeLists          — flattened in/out scope synonyms
+ *   2. constraintRules     — detection patterns per soul constraint
+ *   3. antiPatternLists    — product + per-principle + voice + visual
+ *   4. measurableSignals   — principle signals + visual constraints
+ *   5. bm25Corpus          — SA-1 corpus (mission + experientialTargets,
+ *                            core fields weighted 2×, evolving 1×)
+ *   6. principleCorpora    — one SA-2 corpus per designPrinciple
+ *
+ * The output is stable given identical input (canonical JSON + sha256
+ * hash) so `did_compiled_artifacts.source_hash` can be used to detect
+ * DID changes cheaply.
+ */
+import { createHash } from 'node:crypto';
+// ── Tokenization ─────────────────────────────────────────────────────
+const STOPWORDS = new Set([
+    'the',
+    'and',
+    'for',
+    'are',
+    'with',
+    'from',
+    'that',
+    'this',
+    'will',
+    'have',
+    'has',
+    'been',
+    'were',
+    'your',
+    'our',
+    'their',
+    'they',
+    'must',
+    'may',
+    'not',
+    'into',
+    'onto',
+    'than',
+    'but',
+    'any',
+    'all',
+]);
+export function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter((t) => t.length >= 3 && !STOPWORDS.has(t));
+}
+// ── Canonical JSON + hash ────────────────────────────────────────────
+/**
+ * Stable JSON: keys sorted alphabetically at every depth. Matches the
+ * Python json.dumps(sort_keys=True) output so cross-language consumers
+ * agree on the source hash.
+ */
+export function canonicalJson(value) {
+    return JSON.stringify(value, (_key, v) => {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            const sorted = {};
+            for (const k of Object.keys(v).sort()) {
+                sorted[k] = v[k];
+            }
+            return sorted;
+        }
+        return v;
+    });
+}
+export function hashDidSpec(did) {
+    return createHash('sha256').update(canonicalJson(did.spec)).digest('hex');
+}
+// ── Helpers ──────────────────────────────────────────────────────────
+function ic(input) {
+    return input?.identityClass ?? 'evolving';
+}
+function compileScopeEntry(term) {
+    return {
+        label: term.label,
+        synonyms: term.synonyms ? Array.from(new Set(term.synonyms)) : [],
+        identityClass: ic(term),
+    };
+}
+function compileConstraint(c) {
+    return {
+        id: c.id,
+        concept: c.concept,
+        relationship: c.relationship,
+        detectionPatterns: [...c.detectionPatterns],
+        identityClass: ic(c),
+    };
+}
+function compileAntiPattern(a) {
+    return {
+        id: a.id,
+        label: a.label,
+        detectionPatterns: [...a.detectionPatterns],
+        identityClass: ic(a),
+    };
+}
+function buildBm25Document(id, text, identityClass) {
+    const tokens = tokenize(text);
+    if (tokens.length === 0)
+        return undefined;
+    return { id, tokens, weight: identityClass === 'core' ? 2 : 1 };
+}
+// ── Compilation entry point ──────────────────────────────────────────
+export function compileDid(did) {
+    const spec = did.spec;
+    // 1. Scope lists
+    const scopeLists = {
+        inScope: (spec.soulPurpose.scopeBoundaries?.inScope ?? []).map(compileScopeEntry),
+        outOfScope: (spec.soulPurpose.scopeBoundaries?.outOfScope ?? []).map(compileScopeEntry),
+    };
+    // 2. Constraint rules
+    const constraintRules = (spec.soulPurpose.constraints ?? []).map(compileConstraint);
+    // 3. Anti-pattern lists
+    const productAntiPatterns = (spec.soulPurpose.antiPatterns ?? []).map(compileAntiPattern);
+    const perPrinciple = {};
+    for (const p of spec.soulPurpose.designPrinciples) {
+        perPrinciple[p.id] = (p.antiPatterns ?? []).map(compileAntiPattern);
+    }
+    const voiceAntiPatterns = (spec.brandIdentity?.voiceAntiPatterns ?? []).map(compileAntiPattern);
+    const visualAntiPatterns = (spec.brandIdentity?.visualIdentity?.visualAntiPatterns ?? []).map(compileAntiPattern);
+    const antiPatternLists = {
+        product: productAntiPatterns,
+        perPrinciple,
+        voice: voiceAntiPatterns,
+        visual: visualAntiPatterns,
+    };
+    // 4. Measurable signals (principle + visual)
+    const measurableSignals = [];
+    for (const principle of spec.soulPurpose.designPrinciples) {
+        for (const sig of principle.measurableSignals ?? []) {
+            measurableSignals.push({
+                id: sig.id,
+                metric: sig.metric,
+                threshold: sig.threshold,
+                operator: sig.operator,
+                scope: sig.scope,
+                sourcePrinciple: principle.id,
+                identityClass: sig.identityClass ?? principle.identityClass ?? 'evolving',
+            });
+        }
+    }
+    for (const vc of spec.brandIdentity?.visualIdentity?.visualConstraints ?? []) {
+        measurableSignals.push(compileVisualConstraintSignal(vc));
+    }
+    // 5. SA-1 BM25 corpus (mission + experientialTargets)
+    const bm25Docs = [];
+    const missionDoc = buildBm25Document('mission', spec.soulPurpose.mission.value, ic(spec.soulPurpose.mission));
+    if (missionDoc)
+        bm25Docs.push(missionDoc);
+    for (const [name, target] of Object.entries(spec.experientialTargets ?? {})) {
+        if (!target)
+            continue;
+        const doc = buildBm25Document(`experientialTargets.${name}`, JSON.stringify(target), ic(target));
+        if (doc)
+            bm25Docs.push(doc);
+    }
+    const bm25Corpus = { documents: bm25Docs };
+    // 6. SA-2 principle corpora
+    const principleCorpora = {};
+    for (const principle of spec.soulPurpose.designPrinciples) {
+        principleCorpora[principle.id] = buildPrincipleCorpus(principle);
+    }
+    return {
+        didName: did.metadata.name,
+        namespace: did.metadata.namespace,
+        sourceHash: hashDidSpec(did),
+        scopeLists,
+        constraintRules,
+        antiPatternLists,
+        measurableSignals,
+        bm25Corpus,
+        principleCorpora,
+    };
+}
+function compileVisualConstraintSignal(vc) {
+    return {
+        id: vc.id,
+        metric: vc.rule.metric,
+        threshold: vc.rule.threshold,
+        operator: vc.rule.operator,
+        sourceVisual: vc.id,
+        identityClass: ic(vc),
+    };
+}
+function buildPrincipleCorpus(principle) {
+    const pic = principle.identityClass ?? 'evolving';
+    const docs = [];
+    const nameDoc = buildBm25Document(`${principle.id}.name`, principle.name, pic);
+    if (nameDoc)
+        docs.push(nameDoc);
+    const descDoc = buildBm25Document(`${principle.id}.description`, principle.description, pic);
+    if (descDoc)
+        docs.push(descDoc);
+    for (const sig of principle.measurableSignals ?? []) {
+        const doc = buildBm25Document(`${principle.id}.signal.${sig.id}`, `${sig.metric} ${sig.operator} ${sig.threshold}`, sig.identityClass ?? pic);
+        if (doc)
+            docs.push(doc);
+    }
+    for (const ap of principle.antiPatterns ?? []) {
+        const doc = buildBm25Document(`${principle.id}.antipattern.${ap.id}`, `${ap.label} ${ap.detectionPatterns.join(' ')}`, ap.identityClass ?? pic);
+        if (doc)
+            docs.push(doc);
+    }
+    return { documents: docs };
+}
+/**
+ * Enforce the §B.10.2 minimums a DID must meet before Phase-2b scoring
+ * is safe to enable. Returns a list of gaps; empty ⇒ ready.
+ */
+export function validatePhase2bReadiness(compiled) {
+    const gaps = [];
+    // ≥ 2 constraints with ≥ 3 detection patterns
+    const qualifyingConstraints = compiled.constraintRules.filter((c) => c.detectionPatterns.length >= 3);
+    if (qualifyingConstraints.length < 2) {
+        gaps.push(`Need ≥2 constraints with ≥3 detection patterns each (got ${qualifyingConstraints.length})`);
+    }
+    // ≥ 3 outOfScope entries with ≥ 2 synonyms
+    const outOfScopeOk = compiled.scopeLists.outOfScope.filter((s) => s.synonyms.length >= 2);
+    if (outOfScopeOk.length < 3) {
+        gaps.push(`Need ≥3 outOfScope entries with ≥2 synonyms each (got ${outOfScopeOk.length})`);
+    }
+    // ≥ 3 product-level antiPatterns with ≥ 3 patterns
+    const productAntiOk = compiled.antiPatternLists.product.filter((a) => a.detectionPatterns.length >= 3);
+    if (productAntiOk.length < 3) {
+        gaps.push(`Need ≥3 product-level antiPatterns with ≥3 detection patterns each (got ${productAntiOk.length})`);
+    }
+    // ≥ 1 principle with ≥ 2 antiPatterns having ≥ 2 patterns each
+    const principlesWithAnti = Object.entries(compiled.antiPatternLists.perPrinciple).filter(([, list]) => list.filter((a) => a.detectionPatterns.length >= 2).length >= 2);
+    if (principlesWithAnti.length < 1) {
+        gaps.push('Need ≥1 designPrinciple with ≥2 antiPatterns (each with ≥2 detection patterns)');
+    }
+    // ≥ 2 voice antiPatterns with ≥ 2 patterns
+    const voiceOk = compiled.antiPatternLists.voice.filter((a) => a.detectionPatterns.length >= 2);
+    if (voiceOk.length < 2) {
+        gaps.push(`Need ≥2 voice antiPatterns with ≥2 detection patterns each (got ${voiceOk.length})`);
+    }
+    // ≥ 2 visual antiPatterns with ≥ 2 patterns
+    const visualOk = compiled.antiPatternLists.visual.filter((a) => a.detectionPatterns.length >= 2);
+    if (visualOk.length < 2) {
+        gaps.push(`Need ≥2 visual antiPatterns with ≥2 detection patterns each (got ${visualOk.length})`);
+    }
+    return { ready: gaps.length === 0, gaps };
+}
+// ── State-store serialization helpers ────────────────────────────────
+export function serializeForStore(compiled) {
+    return {
+        didName: compiled.didName,
+        namespace: compiled.namespace,
+        sourceHash: compiled.sourceHash,
+        scopeListsJson: canonicalJson(compiled.scopeLists),
+        constraintRulesJson: canonicalJson(compiled.constraintRules),
+        antiPatternListsJson: canonicalJson(compiled.antiPatternLists),
+        measurableSignalsJson: canonicalJson(compiled.measurableSignals),
+        bm25CorpusBlob: Buffer.from(canonicalJson(compiled.bm25Corpus), 'utf-8'),
+        principleCorporaBlob: Buffer.from(canonicalJson(compiled.principleCorpora), 'utf-8'),
+    };
+}
+export function deserializeFromStore(record) {
+    const parse = (json, fallback) => json ? JSON.parse(json) : fallback;
+    const parseBuffer = (buf, fallback) => buf ? JSON.parse(buf.toString('utf-8')) : fallback;
+    return {
+        didName: record.didName,
+        namespace: record.namespace,
+        sourceHash: record.sourceHash,
+        scopeLists: parse(record.scopeListsJson, { inScope: [], outOfScope: [] }),
+        constraintRules: parse(record.constraintRulesJson, []),
+        antiPatternLists: parse(record.antiPatternListsJson, {
+            product: [],
+            perPrinciple: {},
+            voice: [],
+            visual: [],
+        }),
+        measurableSignals: parse(record.measurableSignalsJson, []),
+        bm25Corpus: parseBuffer(record.bm25CorpusBlob, { documents: [] }),
+        principleCorpora: parseBuffer(record.principleCorporaBlob, {}),
+    };
+}
+//# sourceMappingURL=did-compiler.js.map