@latysh-development/monolith 0.0.0-stage → 0.1.0-alpha.0

package/dist/graph/builder.js

@@ -0,0 +1,153 @@
+import { compareObjects, isValidIdentifier, makeRef } from './identity.js';
+import { buildObjectIndex, resolveRef } from './resolver.js';
+/**
+ * Builds the explicit relationship graph.
+ *
+ * Nodes are KnowledgeObjects declared by Scriptorium (document `id:` and `{#ID}` sections).
+ * Concepts are not nodes. An edge exists only when its target resolves (RESOLVED) from a
+ * source that itself has a unique canonical identity. Output is independent of input order.
+ */
+export function buildGraph(results) {
+    if (results.length === 0) {
+        return {
+            nodes: [],
+            edges: [],
+            unresolved: [],
+            conflicts: [],
+            diagnostics: [{ severity: 'info', message: 'No ScriptoriumResult inputs provided — graph is empty.' }],
+        };
+    }
+    const diagnostics = [];
+    const ordered = [...results].sort((a, b) => cmp(a.artifactId, b.artifactId) || cmp(a.sourcePath ?? '', b.sourcePath ?? ''));
+    // --- Pass 1: validate declarations into KnowledgeObjects ---
+    const declared = [];
+    const documentOf = new Map(); // result → document ref
+    const loadedNamespaces = new Set();
+    for (const result of ordered) {
+        const { artifactId } = result;
+        const namespace = result.namespace;
+        if (namespace === undefined || !isValidIdentifier(namespace)) {
+            if (result.declarations.length > 0 || result.relationships.length > 0) {
+                diagnostics.push({
+                    severity: 'error',
+                    message: namespace === undefined
+                        ? 'Artifact has no namespace; its declarations and relationships cannot be given a canonical identity'
+                        : `Invalid namespace "${namespace}"; its declarations and relationships cannot be given a canonical identity`,
+                    artifactId,
+                });
+            }
+            continue;
+        }
+        loadedNamespaces.add(namespace);
+        for (const decl of result.declarations) {
+            if (!isValidIdentifier(decl.localId)) {
+                diagnostics.push({
+                    severity: 'error',
+                    message: `Invalid local id "${decl.localId}" in ${decl.kind} declaration; object ignored`,
+                    artifactId,
+                });
+                continue;
+            }
+            const obj = {
+                ref: makeRef(namespace, decl.localId),
+                namespace,
+                localId: decl.localId,
+                kind: decl.kind,
+                ...(decl.title !== undefined ? { title: decl.title } : {}),
+                ...(decl.status !== undefined ? { status: decl.status } : {}),
+                location: {
+                    artifactId,
+                    path: result.sourcePath ?? artifactId,
+                    ...(decl.sourceLine !== undefined ? { line: decl.sourceLine } : {}),
+                },
+            };
+            declared.push(obj);
+            if (decl.kind === 'document' && !documentOf.has(result))
+                documentOf.set(result, obj.ref);
+        }
+    }
+    // --- Pass 2: uniqueness. A ref held by more than one object is a conflict, never a node. ---
+    const index = buildObjectIndex(declared, loadedNamespaces);
+    const nodes = [];
+    const conflicts = [];
+    for (const [ref, list] of index.byRef) {
+        if (list.length === 1) {
+            nodes.push(list[0]);
+        }
+        else {
+            conflicts.push({ ref, candidates: [...list] });
+            diagnostics.push({
+                severity: 'error',
+                message: `Identity conflict: ${list.length} objects declare "${ref}" (${list
+                    .map(o => `${o.location.artifactId}${o.location.line !== undefined ? `:${o.location.line}` : ''}`)
+                    .join(', ')}); none is resolvable`,
+            });
+        }
+    }
+    nodes.sort(compareObjects);
+    conflicts.sort((a, b) => cmp(a.ref, b.ref));
+    // --- Pass 3: relationships → edges (RESOLVED only) ---
+    const edges = [];
+    const edgeDedup = new Map();
+    const unresolved = [];
+    for (const result of ordered) {
+        if (result.relationships.length === 0)
+            continue;
+        const fromRef = documentOf.get(result);
+        const fromOk = fromRef !== undefined && index.byRef.get(fromRef)?.length === 1;
+        if (!fromOk) {
+            if (result.namespace !== undefined && isValidIdentifier(result.namespace)) {
+                diagnostics.push({
+                    severity: 'warn',
+                    message: fromRef === undefined
+                        ? `Artifact declares no document id; ${result.relationships.length} relationship(s) have no canonical source and create no edges`
+                        : `Document "${fromRef}" is in an identity conflict; ${result.relationships.length} relationship(s) create no edges`,
+                    artifactId: result.artifactId,
+                });
+            }
+            continue;
+        }
+        for (const rel of result.relationships) {
+            const resolution = resolveRef(rel.toLabel, result.namespace, index);
+            if (resolution.status !== 'RESOLVED') {
+                unresolved.push({
+                    fromRef,
+                    rawRef: rel.toLabel,
+                    relationshipType: rel.relationshipType,
+                    resolution,
+                    sourceArtifactId: result.artifactId,
+                    evidenceId: rel.id,
+                    ...(rel.sourceLine !== undefined ? { sourceLine: rel.sourceLine } : {}),
+                });
+                continue;
+            }
+            const toRef = resolution.object.ref;
+            const key = `${fromRef}|${rel.relationshipType}|${toRef}|${result.artifactId}`;
+            const existing = edgeDedup.get(key);
+            if (existing !== undefined) {
+                edges[existing].evidenceIds.push(rel.id);
+            }
+            else {
+                edgeDedup.set(key, edges.length);
+                edges.push({
+                    id: key,
+                    fromRef,
+                    toRef,
+                    relationshipType: rel.relationshipType,
+                    provenance: 'explicit',
+                    evidenceIds: [rel.id],
+                    sourceArtifactId: result.artifactId,
+                    ...(rel.sourceLine !== undefined ? { sourceLine: rel.sourceLine } : {}),
+                });
+            }
+        }
+    }
+    edges.sort((a, b) => cmp(a.id, b.id));
+    unresolved.sort((a, b) => cmp(a.sourceArtifactId, b.sourceArtifactId) ||
+        cmp(a.evidenceId, b.evidenceId) ||
+        cmp(a.rawRef, b.rawRef));
+    return { nodes, edges, unresolved, conflicts, diagnostics };
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}

package/dist/graph/identity.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Canonical Knowledge Identity.
+ *
+ * ref = namespace:localId. Neither part is derived from a title, a path or a slug:
+ * namespace is supplied by the caller, localId is declared in the artifact
+ * (frontmatter `id:` or a `{#ID}` heading marker). Identifiers are case-sensitive.
+ */
+export type KnowledgeObjectKind = 'document' | 'section';
+export interface KnowledgeObject {
+    ref: string;
+    namespace: string;
+    localId: string;
+    kind: KnowledgeObjectKind;
+    title?: string;
+    status?: string;
+    location: {
+        artifactId: string;
+        path: string;
+        line?: number;
+    };
+}
+export declare function isValidIdentifier(value: string): boolean;
+export declare function makeRef(namespace: string, localId: string): string;
+export type ParsedRef = {
+    ok: true;
+    qualified: boolean;
+    namespace?: string;
+    localId: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Syntactic parse only; whether the ref resolves is the resolver's concern. */
+export declare function parseRef(raw: string): ParsedRef;
+/** Total order used for every candidate list, so output never depends on input order. */
+export declare function compareObjects(a: KnowledgeObject, b: KnowledgeObject): number;
+//# sourceMappingURL=identity.d.ts.map

package/dist/graph/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/graph/identity.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,SAAS,CAAC;AAEzD,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;CACH;AAKD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,MAAM,MAAM,SAAS,GACjB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrE;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAgB/C;AAED,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAQ7E"}

package/dist/graph/identity.js

@@ -0,0 +1,46 @@
+/**
+ * Canonical Knowledge Identity.
+ *
+ * ref = namespace:localId. Neither part is derived from a title, a path or a slug:
+ * namespace is supplied by the caller, localId is declared in the artifact
+ * (frontmatter `id:` or a `{#ID}` heading marker). Identifiers are case-sensitive.
+ */
+/** Allowed in both namespace and localId. Excludes ':' (the ref separator), whitespace and braces. */
+const IDENTIFIER_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function isValidIdentifier(value) {
+    return IDENTIFIER_RE.test(value);
+}
+export function makeRef(namespace, localId) {
+    return `${namespace}:${localId}`;
+}
+/** Syntactic parse only; whether the ref resolves is the resolver's concern. */
+export function parseRef(raw) {
+    const value = raw.trim();
+    if (value === '')
+        return { ok: false, reason: 'empty reference' };
+    const parts = value.split(':');
+    if (parts.length > 2)
+        return { ok: false, reason: 'more than one ":" separator' };
+    if (parts.length === 2) {
+        const [namespace, localId] = parts;
+        if (!isValidIdentifier(namespace))
+            return { ok: false, reason: `invalid namespace "${namespace}"` };
+        if (!isValidIdentifier(localId))
+            return { ok: false, reason: `invalid local id "${localId}"` };
+        return { ok: true, qualified: true, namespace, localId };
+    }
+    if (!isValidIdentifier(value))
+        return { ok: false, reason: `invalid local id "${value}"` };
+    return { ok: true, qualified: false, localId: value };
+}
+/** Total order used for every candidate list, so output never depends on input order. */
+export function compareObjects(a, b) {
+    return (cmp(a.ref, b.ref) ||
+        cmp(a.location.artifactId, b.location.artifactId) ||
+        cmp(a.location.path, b.location.path) ||
+        (a.location.line ?? -1) - (b.location.line ?? -1) ||
+        cmp(a.kind, b.kind));
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}

package/dist/graph/index.d.ts

@@ -0,0 +1,7 @@
+export type { GraphNode, GraphEdge, GraphDiagnostic, ExplicitRelationshipGraph, UnresolvedReference, IdentityConflict, } from './types.js';
+export type { KnowledgeObject, KnowledgeObjectKind, ParsedRef } from './identity.js';
+export { makeRef, parseRef, isValidIdentifier } from './identity.js';
+export type { Resolution, UnresolvedResolution, ObjectIndex } from './resolver.js';
+export { buildObjectIndex, resolveRef } from './resolver.js';
+export { buildGraph } from './builder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graph/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,SAAS,EACT,SAAS,EACT,eAAe,EACf,yBAAyB,EACzB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACrE,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/graph/index.js

@@ -0,0 +1,3 @@
+export { makeRef, parseRef, isValidIdentifier } from './identity.js';
+export { buildObjectIndex, resolveRef } from './resolver.js';
+export { buildGraph } from './builder.js';

package/dist/graph/resolver.d.ts

@@ -0,0 +1,41 @@
+import type { KnowledgeObject } from './identity.js';
+/**
+ * Deterministic reference resolution. No fuzzy matching, no title matching,
+ * no LLM, no first-wins: a ref resolves only when exactly one object holds it.
+ */
+export interface ObjectIndex {
+    /** Every declared object by ref. More than one entry means an identity conflict. */
+    byRef: ReadonlyMap<string, readonly KnowledgeObject[]>;
+    /** Namespaces for which at least one artifact was provided as input. */
+    loadedNamespaces: ReadonlySet<string>;
+}
+export type Resolution = {
+    status: 'RESOLVED';
+    ref: string;
+    object: KnowledgeObject;
+} | {
+    status: 'MISSING';
+    ref: string;
+} | {
+    status: 'AMBIGUOUS';
+    ref: string;
+    candidates: KnowledgeObject[];
+} | {
+    status: 'EXTERNAL_UNAVAILABLE';
+    ref: string;
+    namespace: string;
+} | {
+    status: 'INVALID_REF';
+    raw: string;
+    reason: string;
+};
+export type UnresolvedResolution = Exclude<Resolution, {
+    status: 'RESOLVED';
+}>;
+export declare function buildObjectIndex(objects: readonly KnowledgeObject[], loadedNamespaces: Iterable<string>): ObjectIndex;
+/**
+ * @param raw             reference text as written in the source artifact
+ * @param sourceNamespace namespace of the artifact containing the reference
+ */
+export declare function resolveRef(raw: string, sourceNamespace: string, index: ObjectIndex): Resolution;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/graph/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/graph/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD;;;GAGG;AAEH,MAAM,WAAW,WAAW;IAC1B,oFAAoF;IACpF,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC,CAAC;IACvD,wEAAwE;IACxE,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACvC;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC5D;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,eAAe,EAAE,CAAA;CAAE,GACnE;IAAE,MAAM,EAAE,sBAAsB,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAClE;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,UAAU,EAAE;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC;AAE/E,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,GACjC,WAAW,CASb;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,UAAU,CAiB/F"}

package/dist/graph/resolver.js

@@ -0,0 +1,36 @@
+import { compareObjects, makeRef, parseRef } from './identity.js';
+export function buildObjectIndex(objects, loadedNamespaces) {
+    const byRef = new Map();
+    for (const obj of objects) {
+        const list = byRef.get(obj.ref);
+        if (list)
+            list.push(obj);
+        else
+            byRef.set(obj.ref, [obj]);
+    }
+    for (const list of byRef.values())
+        list.sort(compareObjects);
+    return { byRef, loadedNamespaces: new Set(loadedNamespaces) };
+}
+/**
+ * @param raw             reference text as written in the source artifact
+ * @param sourceNamespace namespace of the artifact containing the reference
+ */
+export function resolveRef(raw, sourceNamespace, index) {
+    const parsed = parseRef(raw);
+    if (!parsed.ok)
+        return { status: 'INVALID_REF', raw, reason: parsed.reason };
+    // Rule 2: an unqualified id is looked up only inside the source's own namespace.
+    const namespace = parsed.qualified ? parsed.namespace : sourceNamespace;
+    const ref = makeRef(namespace, parsed.localId);
+    // Rule 5: a namespace with no loaded corpus is unavailable, not a missing local object.
+    if (!index.loadedNamespaces.has(namespace)) {
+        return { status: 'EXTERNAL_UNAVAILABLE', ref, namespace };
+    }
+    const candidates = index.byRef.get(ref);
+    if (!candidates || candidates.length === 0)
+        return { status: 'MISSING', ref };
+    if (candidates.length > 1)
+        return { status: 'AMBIGUOUS', ref, candidates: [...candidates] };
+    return { status: 'RESOLVED', ref, object: candidates[0] };
+}

package/dist/graph/types.d.ts

@@ -0,0 +1,42 @@
+import type { KnowledgeObject } from './identity.js';
+import type { UnresolvedResolution } from './resolver.js';
+/** A graph node is a canonical KnowledgeObject. There are no concept, alias or synthesized nodes. */
+export type GraphNode = KnowledgeObject;
+export interface GraphEdge {
+    id: string;
+    fromRef: string;
+    toRef: string;
+    relationshipType: string;
+    provenance: 'explicit';
+    evidenceIds: string[];
+    sourceArtifactId: string;
+    sourceLine?: number;
+}
+/** A relationship whose target did not resolve to exactly one object. No edge exists for it. */
+export interface UnresolvedReference {
+    fromRef: string;
+    rawRef: string;
+    relationshipType: string;
+    resolution: UnresolvedResolution;
+    sourceArtifactId: string;
+    evidenceId: string;
+    sourceLine?: number;
+}
+/** Two or more declarations claim the same `ref`. None of them becomes a node. */
+export interface IdentityConflict {
+    ref: string;
+    candidates: KnowledgeObject[];
+}
+export interface GraphDiagnostic {
+    severity: 'info' | 'warn' | 'error';
+    message: string;
+    artifactId?: string;
+}
+export interface ExplicitRelationshipGraph {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    unresolved: UnresolvedReference[];
+    conflicts: IdentityConflict[];
+    diagnostics: GraphDiagnostic[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/graph/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/graph/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,qGAAqG;AACrG,MAAM,MAAM,SAAS,GAAG,eAAe,CAAC;AAExC,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,gGAAgG;AAChG,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,oBAAoB,CAAC;IACjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC"}

package/dist/graph/types.js

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

package/dist/http/index.d.ts

@@ -0,0 +1,5 @@
+export { startDashboardServer, DASHBOARD_PATH, LOOPBACK_HOST, MAX_RESPONSE_BYTES } from './server.js';
+export type { DashboardServer, DashboardServerOptions, HttpErrorBody, HttpErrorCode, HttpErrorKind, UiAsset, UiAssets, } from './server.js';
+export { loadUiAssets, UiAssetsError } from './ui-assets.js';
+export type { UiAssetsErrorCode } from './ui-assets.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtG,YAAY,EACV,eAAe,EACf,sBAAsB,EACtB,aAAa,EACb,aAAa,EACb,aAAa,EACb,OAAO,EACP,QAAQ,GACT,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC7D,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/http/index.js

@@ -0,0 +1,2 @@
+export { startDashboardServer, DASHBOARD_PATH, LOOPBACK_HOST, MAX_RESPONSE_BYTES } from './server.js';
+export { loadUiAssets, UiAssetsError } from './ui-assets.js';

package/dist/http/server.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Secure read-only HTTP transport for Mission Control (UI-001B.2, ADR-010 G2).
+ *
+ * One endpoint, `GET /api/dashboard`, serves the existing `DashboardReadModel`
+ * exactly as `readDashboardModel(projectRoot)` returns it. This module is a
+ * transport only:
+ *  - it reads no file and imports no filesystem module; every byte of project
+ *    data arrives through `readDashboardModel` (ADR-014 safe read);
+ *  - it knows nothing about `state.json`, its schema or its physical layout, so
+ *    the Core storage can change (STATE-003) without touching this layer;
+ *  - the project root is fixed when the server starts and is never taken from a
+ *    request (query, body, header or cookie are not read for that purpose).
+ *
+ * With `options.assets` it also serves the built UI from memory (`monolith ui`);
+ * the API route, the Host/Origin checks and the loopback bind are unchanged.
+ *
+ * Security boundary (G2): bound to 127.0.0.1 only; `Host` allowlist (loopback
+ * name + the real port, against DNS rebinding); `Origin` checked when present
+ * and never reflected; no CORS headers at all; GET only; fixed response
+ * headers; bounded response size with no partial JSON; errors are fixed codes,
+ * never exception text or paths. Loopback is NOT treated as authentication.
+ *
+ * Source failures (absent / forbidden / corrupt / unreadable) are part of the
+ * DTO (`SourceReport`) and keep their Typed Read Model semantics: they are a
+ * valid 200 response carrying `data: null` and a typed code, never project
+ * content. Threat model (ADR-013): TM-A supported with limitations, TM-B
+ * partially supported, TM-C (concurrent adversarial mutation) NOT supported;
+ * dynamic TOCTOU is not closed here, nor by Core.
+ */
+export declare const DASHBOARD_PATH = "/api/dashboard";
+/** The only bind address; there is deliberately no option to change it. */
+export declare const LOOPBACK_HOST = "127.0.0.1";
+/**
+ * Hard ceiling for one serialized response. The Core read limits (state 16 MiB,
+ * active.md/roadmap 256 KiB) are protective ceilings of their own and can exceed
+ * it; an over-limit DTO is refused whole, never truncated.
+ */
+export declare const MAX_RESPONSE_BYTES: number;
+/** One file of the built UI, held in memory (loaded by `ui-assets.ts`, which is the only place that touches the disk). */
+export interface UiAsset {
+    readonly body: Buffer;
+    readonly contentType: string;
+}
+/** Request path (`/index.html`, `/assets/x.js`) -> asset. */
+export type UiAssets = ReadonlyMap<string, UiAsset>;
+export type HttpErrorKind = 'request' | 'security' | 'dashboard' | 'internal';
+export type HttpErrorCode = 'HOST_NOT_ALLOWED' | 'ORIGIN_NOT_ALLOWED' | 'NOT_FOUND' | 'METHOD_NOT_ALLOWED' | 'RESPONSE_TOO_LARGE' | 'INTERNAL_ERROR';
+/** Body of every non-200 response. Fixed vocabulary only: no message, path or detail. */
+export interface HttpErrorBody {
+    error: {
+        kind: HttpErrorKind;
+        code: HttpErrorCode;
+    };
+}
+export interface DashboardServerOptions {
+    /** Absolute project root, chosen by the embedding process. */
+    projectRoot: string;
+    /** 0 (default) lets the OS pick a free port; read the result from `DashboardServer.port`. */
+    port?: number;
+    /** Overrides MAX_RESPONSE_BYTES (tests, tighter deployments). */
+    maxResponseBytes?: number;
+    /**
+     * The built UI, already in memory (`loadUiAssets`). When given, `GET /` and
+     * `GET <asset path>` serve it; the match is by exact key, so no request path
+     * is ever mapped onto the filesystem. When absent, only the API exists.
+     */
+    assets?: UiAssets;
+}
+export interface DashboardServer {
+    readonly host: typeof LOOPBACK_HOST;
+    readonly port: number;
+    readonly url: string;
+    close(): Promise<void>;
+}
+export declare function startDashboardServer(options: DashboardServerOptions): Promise<DashboardServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/http/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/http/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAOH,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAC/C,2EAA2E;AAC3E,eAAO,MAAM,aAAa,cAAc,CAAC;AACzC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,QAAkB,CAAC;AAElD,0HAA0H;AAC1H,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,6DAA6D;AAC7D,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC;AAC9E,MAAM,MAAM,aAAa,GACrB,kBAAkB,GAClB,oBAAoB,GACpB,WAAW,GACX,oBAAoB,GACpB,oBAAoB,GACpB,gBAAgB,CAAC;AAErB,yFAAyF;AACzF,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE;QAAE,IAAI,EAAE,aAAa,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC;CACrD;AAED,MAAM,WAAW,sBAAsB;IACrC,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,6FAA6F;IAC7F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,OAAO,aAAa,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAmFD,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4EpG"}