@ssot-registry/lineage-graph 0.2.25-dev.5

package/dist/standalone.d.ts

@@ -0,0 +1,6 @@
+import type { LineagePayload } from "./types";
+declare global {
+    interface Window {
+        __SSOT_LINEAGE_PAYLOAD__?: LineagePayload;
+    }
+}

package/dist/subcomponents/KeyValue.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function KeyValue({ record, keys }: {
+    record?: Record<string, unknown>;
+    keys?: string[];
+}): React.ReactElement;

package/dist/subcomponents/Section.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export declare function Section({ title, children, className, collapsible, defaultOpen, }: {
+    title?: string;
+    children: React.ReactNode;
+    className?: string;
+    collapsible?: boolean;
+    defaultOpen?: boolean;
+}): React.ReactElement;

package/dist/subcomponents/StatCard.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function StatCard({ value, label }: {
+    value: unknown;
+    label: string;
+}): React.ReactElement;

package/dist/subcomponents/format.d.ts

@@ -0,0 +1 @@
+export declare function valueText(value: unknown): string;

package/dist/types.d.ts

@@ -0,0 +1,179 @@
+export type LineageFamily = "ADR" | "Boundary" | "Claim" | "Evidence" | "Feature" | "Issue" | "Profile" | "Release" | "Risk" | "Spec" | "SPEC" | "Test" | string;
+export type LayoutMode = "network" | "lineage";
+export type RendererPreference = "auto" | "webgl" | "canvas";
+export type RendererMode = "webgl" | "canvas";
+export type DepthSetting = "1" | "2" | "3" | "max";
+export interface LineageNode {
+    id: string;
+    family: LineageFamily;
+    label?: string;
+    title?: string;
+    summary?: string;
+    description?: string;
+    status?: string;
+    lifecycle?: {
+        stage?: string;
+        state?: string;
+        promotedAt?: string;
+        certifiedAt?: string;
+        publishedAt?: string;
+    };
+    tier?: string;
+    origin?: string;
+    originKind?: string;
+    originRef?: string;
+    source?: {
+        path?: string;
+        line?: number;
+        url?: string;
+        documentId?: string;
+    };
+    path?: string;
+    degree?: number;
+    tags?: string[];
+    packs?: string[];
+    governancePacks?: string[];
+    contractPacks?: string[];
+    boundaries?: string[];
+    releases?: string[];
+    profiles?: string[];
+    validation?: {
+        status?: "pass" | "warn" | "fail" | "unknown";
+        issues?: string[];
+        lastCheckedAt?: string;
+    };
+    proof?: {
+        claimTier?: string;
+        testStatus?: string;
+        evidenceStatus?: string;
+        releaseStatus?: string;
+        completeness?: number;
+    };
+    metrics?: {
+        upstreamCount?: number;
+        downstreamCount?: number;
+        blockerCount?: number;
+        staleEdgeCount?: number;
+    };
+    links?: Array<{
+        label: string;
+        href: string;
+        kind?: string;
+    }>;
+    x?: number;
+    y?: number;
+    vx?: number;
+    vy?: number;
+    pinned?: boolean;
+}
+export interface LineageEdge {
+    from: string;
+    to: string;
+    type?: string;
+    label?: string;
+    direction?: "forward" | "reverse" | "bidirectional";
+    status?: "active" | "planned" | "deprecated" | "stale" | "missing" | "invalid" | "unknown";
+    originKind?: string;
+    strength?: number;
+    tier?: string;
+    source?: {
+        path?: string;
+        line?: number;
+        field?: string;
+        url?: string;
+    };
+    proof?: {
+        required?: boolean;
+        satisfied?: boolean;
+        blocker?: boolean;
+        reason?: string;
+    };
+    pack?: {
+        id?: string;
+        kind?: string;
+    };
+}
+export interface LineageGroup {
+    id: string;
+    kind: string;
+    label: string;
+    nodeIds: string[];
+    status?: string;
+    originKind?: string;
+    summary?: string;
+}
+export interface LineagePayload {
+    schemaVersion?: string;
+    generatedAt?: string;
+    generator?: {
+        name?: string;
+        version?: string;
+        command?: string;
+    };
+    registry?: {
+        path?: string;
+        repoRoot?: string;
+        schemaVersion?: string;
+        validationStatus?: "valid" | "invalid" | "unknown";
+    };
+    package?: {
+        id?: string;
+        name?: string;
+        version?: string;
+        kind?: string;
+        repositoryUrl?: string;
+        canonicalUrl?: string;
+    };
+    nodes: LineageNode[];
+    edges: LineageEdge[];
+    groups?: LineageGroup[];
+    summaries?: Record<string, unknown>;
+    summary?: Record<string, unknown>;
+}
+export interface SelectionState {
+    selectedNodeId: string | null;
+    selectedEdgeIndex: number | null;
+    focusNodeId: string | null;
+}
+export interface RendererOptions {
+    renderer?: RendererPreference;
+    layoutMode?: LayoutMode;
+    initialDepth?: DepthSetting;
+    initialNodeLimit?: number | "all";
+    forceCutoff?: number;
+    forceStrength?: number;
+    repulsionStrength?: number;
+    edgeOpacity?: number;
+    edgeWidth?: number;
+    ribbonCulling?: "off" | "light" | "strong";
+}
+export interface LineageGraphProps {
+    payload: LineagePayload;
+    options?: RendererOptions;
+    className?: string;
+    onSelectionChange?: (selection: SelectionState) => void;
+}
+export interface ViewportState {
+    x: number;
+    y: number;
+    zoom: number;
+}
+export interface PositionedNode extends Required<Pick<LineageNode, "id" | "family">> {
+    label: string;
+    status: string;
+    tier: string;
+    origin: string;
+    path: string;
+    degree: number;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    pinned: boolean;
+}
+export interface StandaloneHtmlOptions {
+    title?: string;
+    script?: string;
+    style?: string;
+    rootId?: string;
+}

package/dist/views/LineageGraphAppView.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "../styles.css";
+import "../workspace/index.css";
+import type { LineagePayload } from "../types";
+interface LineageGraphAppProps {
+    payload: LineagePayload;
+    selectedRegistryKey?: string;
+    onChangeRegistry?: (key: string) => void;
+    registryOptions?: Array<{
+        key: string;
+        label: string;
+    }>;
+    defaultMode?: "network" | "lineage" | "proof" | "release" | "origins" | "packs" | "validation";
+    theme?: "light" | "steel-dark";
+    showDocumentation?: boolean;
+}
+export declare function LineageGraphApp(props: LineageGraphAppProps): React.ReactElement;
+export {};

package/dist/workspace/App.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export default function App(): import("react").JSX.Element;

package/dist/workspace/components/LeftSidebar.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from "react";
+import { LineagePayload, LineageNode, GraphFilters, OriginKind, GraphViewMode } from "../types";
+interface LeftSidebarProps {
+    payload: LineagePayload;
+    filters: GraphFilters;
+    onUpdateFilters: (next: GraphFilters) => void;
+    viewMode: GraphViewMode;
+    onChangeViewMode: (mode: GraphViewMode) => void;
+    selectedRegistryKey: string;
+    onChangeRegistry: (key: string) => void;
+    registryOptions?: Array<{
+        key: string;
+        label: string;
+    }>;
+    allPacks: string[];
+    allTiers: string[];
+    allOriginKinds: OriginKind[];
+    filteredNodes: LineageNode[];
+    isCollapsed: boolean;
+    onToggleCollapse: () => void;
+    onSelectNode?: (id: string | null) => void;
+    onFocusNode?: (id: string | null) => void;
+    nodeLimit?: number;
+    onUpdateNodeLimit?: (limit: number) => void;
+    egoHops?: number;
+    onUpdateEgoHops?: (hops: number) => void;
+    isolateEgo?: boolean;
+    onUpdateIsolateEgo?: (val: boolean) => void;
+}
+export declare const LeftSidebar: React.FC<LeftSidebarProps>;
+export {};

package/dist/workspace/components/LineageGraphApp.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from "react";
+import { LineagePayload, LineageNode, LineageEdge, GraphViewMode, ViewSettings } from "../types";
+interface LineageGraphAppProps {
+    payload: LineagePayload;
+    selectedRegistryKey?: string;
+    onChangeRegistry?: (key: string) => void;
+    registryOptions?: Array<{
+        key: string;
+        label: string;
+    }>;
+    defaultMode?: GraphViewMode;
+    theme?: ViewSettings["theme"];
+    showDocumentation?: boolean;
+    precomputedIndices?: {
+        nodeMap: Map<string, LineageNode>;
+        incoming: Map<string, string[]>;
+        outgoing: Map<string, string[]>;
+        edgeMap: Map<string, LineageEdge[]>;
+    };
+}
+export declare const LineageGraphApp: React.FC<LineageGraphAppProps>;
+export default LineageGraphApp;

package/dist/workspace/components/LineageGraphCanvas.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from "react";
+import { LineagePayload, LineageNode, LineageEdge, GraphViewMode, ViewSettings, NodePositions } from "../types";
+interface LineageGraphCanvasProps {
+    payload: LineagePayload;
+    positions: NodePositions;
+    mode: GraphViewMode;
+    selectedNodeId: string | null;
+    selectedNodeIds?: Set<string>;
+    focusNodeId: string | null;
+    collapsedNodeIds: Set<string>;
+    hiddenNodeIds: Set<string>;
+    onSelectNode: (id: string | null, isShiftPressed?: boolean) => void;
+    onToggleCollapse: (id: string) => void;
+    onToggleHideNode: (id: string) => void;
+    onClearHiddenNodes: () => void;
+    onUpdatePositions: (next: NodePositions) => void;
+    viewSettings: ViewSettings;
+    precomputedIndices?: {
+        nodeMap: Map<string, LineageNode>;
+        incoming: Map<string, string[]>;
+        outgoing: Map<string, string[]>;
+        edgeMap: Map<string, LineageEdge[]>;
+    };
+    egoHops?: number;
+    onAddGroup?: (group: any) => void;
+    onBulkHideNodes?: (ids: string[]) => void;
+    onBulkHighlightNodes?: (ids: string[]) => void;
+    highlightedNodeIds?: Set<string>;
+    customGroups?: {
+        id: string;
+        label: string;
+        nodeIds: string[];
+    }[];
+    isolateEgo?: boolean;
+}
+export declare const FAMILY_COLORS: Record<string, {
+    bg: string;
+    text: string;
+    border: string;
+    glow: string;
+}>;
+export declare function generateGhostParallelPaths(startX: number, startY: number, endX: number, endY: number, mode: string, offset: number): string;
+export declare const LineageGraphCanvas: React.FC<LineageGraphCanvasProps>;
+export {};

package/dist/workspace/components/RightInspector.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from "react";
+import { LineagePayload } from "../types";
+interface RightInspectorProps {
+    payload: LineagePayload;
+    selectedNodeId: string | null;
+    focusNodeId: string | null;
+    onSelectNode: (id: string | null) => void;
+    onSetFocusNode: (id: string | null) => void;
+    onClearFocusNode: () => void;
+    isCollapsed: boolean;
+    onToggleCollapse: () => void;
+}
+export declare const RightInspector: React.FC<RightInspectorProps>;
+export {};

package/dist/workspace/components/StorybookDocs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from "react";
+export declare const StorybookDocs: React.FC;

package/dist/workspace/main.d.ts

@@ -0,0 +1 @@
+import './index.css';

package/dist/workspace/types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type GraphViewMode = "network" | "lineage" | "proof" | "release" | "origins" | "packs" | "validation" | "flow-force";
+export type OriginKind = "ssot-core" | "ssot-origin" | "repo-local" | "extension-pack" | "generated" | "unknown" | string;
+export type LineageFamily = "ADR" | "Spec" | "SPEC" | "Feature" | "Claim" | "Test" | "Evidence" | "Boundary" | "Profile" | "Release" | "Risk" | "Issue" | string;
+export interface LineageNode {
+    id: string;
+    family: LineageFamily;
+    label?: string;
+    title?: string;
+    summary?: string;
+    description?: string;
+    body?: string;
+    status?: string;
+    lifecycle?: {
+        stage?: string;
+        state?: string;
+        promotedAt?: string;
+        certifiedAt?: string;
+        publishedAt?: string;
+    };
+    tier?: string;
+    origin?: string;
+    originKind?: OriginKind;
+    originRef?: string;
+    source?: {
+        path?: string;
+        line?: number;
+        url?: string;
+        documentId?: string;
+    };
+    path?: string;
+    degree?: number;
+    tags?: string[];
+    packs?: string[];
+    governancePacks?: string[];
+    contractPacks?: string[];
+    boundaries?: string[];
+    releases?: string[];
+    profiles?: string[];
+    validation?: {
+        status?: "pass" | "warn" | "fail" | "unknown";
+        issues?: string[];
+        lastCheckedAt?: string;
+    };
+    proof?: {
+        claimTier?: string;
+        testStatus?: string;
+        evidenceStatus?: string;
+        releaseStatus?: string;
+        completeness?: number;
+    };
+    metrics?: {
+        upstreamCount?: number;
+        downstreamCount?: number;
+        blockerCount?: number;
+        staleEdgeCount?: number;
+    };
+    links?: Array<{
+        label: string;
+        href: string;
+        kind?: "source" | "docs" | "website" | "issue" | "release" | "external" | string;
+    }>;
+}
+export interface LineageEdge {
+    from: string;
+    to: string;
+    type?: string;
+    label?: string;
+    direction?: "forward" | "reverse" | "bidirectional";
+    status?: "active" | "planned" | "deprecated" | "stale" | "missing" | "invalid" | "unknown";
+    originKind?: "direct" | "derived" | "inferred" | "generated" | "unknown" | string;
+    strength?: number;
+    tier?: string;
+    source?: {
+        path?: string;
+        line?: number;
+        field?: string;
+        url?: string;
+    };
+    proof?: {
+        required?: boolean;
+        satisfied?: boolean;
+        blocker?: boolean;
+        reason?: string;
+    };
+    pack?: {
+        id?: string;
+        kind?: "governance-pack" | "pack-contract" | "extension-pack" | string;
+    };
+}
+export interface LineageGroup {
+    id: string;
+    kind: "boundary" | "release" | "profile" | "package" | "governance-pack" | "pack-contract" | "origin" | string;
+    label: string;
+    nodeIds: string[];
+    status?: string;
+    originKind?: string;
+    summary?: string;
+}
+export interface LineageSummaries {
+    counts?: {
+        nodes?: number;
+        edges?: number;
+        families?: Record<string, number>;
+        statuses?: Record<string, number>;
+        origins?: Record<string, number>;
+        tiers?: Record<string, number>;
+    };
+    proof?: {
+        completeChains?: number;
+        incompleteChains?: number;
+        blockedReleases?: number;
+        missingEvidence?: number;
+        missingTests?: number;
+    };
+    packs?: {
+        governancePacks?: number;
+        contractPacks?: number;
+        extensionPacks?: number;
+    };
+    hotspots?: Array<{
+        nodeId: string;
+        reason: string;
+        score?: number;
+    }>;
+}
+export interface LineagePayload {
+    schemaVersion?: string;
+    generatedAt?: string;
+    generator?: {
+        name?: string;
+        version?: string;
+        command?: string;
+    };
+    registry?: {
+        path?: string;
+        repoRoot?: string;
+        schemaVersion?: string;
+        validationStatus?: "valid" | "invalid" | "unknown";
+    };
+    package?: {
+        id?: string;
+        name?: string;
+        version?: string;
+        kind?: string;
+        repositoryUrl?: string;
+        canonicalUrl?: string;
+    };
+    nodes: LineageNode[];
+    edges: LineageEdge[];
+    groups?: LineageGroup[];
+    summaries?: LineageSummaries;
+    summary?: Record<string, unknown>;
+}
+export interface GraphFilters {
+    search: string;
+    families: Set<LineageFamily>;
+    statuses: Set<string>;
+    originKinds: Set<OriginKind>;
+    tiers: Set<string>;
+    packs: Set<string>;
+    validationStatuses: Set<string>;
+    edgeTypes: Set<string>;
+}
+export interface GraphSelection {
+    selectedNodeId: string | null;
+    selectedEdgeId: string | null;
+    focusNodeId: string | null;
+    focusHistory: string[];
+    collapsedNodeIds: Set<string>;
+}
+export interface ViewSettings {
+    showLabels: boolean;
+    edgeWidth: number;
+    edgeOpacity: number;
+    showMinimap: boolean;
+    theme: "light" | "steel-dark";
+}
+export interface Position {
+    x: number;
+    y: number;
+    vx?: number;
+    vy?: number;
+    fx?: number | null;
+    fy?: number | null;
+}
+export type NodePositions = Record<string, Position>;

package/dist/workspace/utils/graphHelpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LineagePayload, LineageNode, LineageEdge, NodePositions, GraphViewMode } from "../types";
+export declare const FAMILY_LAYERS: Record<string, number>;
+export declare function columnForNode(node: LineageNode, viewMode?: GraphViewMode): number;
+export declare function computeGraphIndices(payload: LineagePayload): {
+    nodeMap: Map<string, LineageNode>;
+    incoming: Map<string, string[]>;
+    outgoing: Map<string, string[]>;
+    edgeMap: Map<string, LineageEdge[]>;
+};
+export declare function hasCollapsedUpstreamAncestor(id: string, incoming: Map<string, string[]>, collapsedIds: Set<string>): boolean;
+export declare function traceSubGraph(nodeId: string, incoming: Map<string, string[]>, outgoing: Map<string, string[]>, depth?: number): {
+    nodes: Set<string>;
+    edges: Set<string>;
+};
+export declare function computeDeterministicLayout(nodes: LineageNode[], incoming: Map<string, string[]>, outgoing: Map<string, string[]>, collapsedIds: Set<string>, scaleX?: number, scaleY?: number, width?: number, height?: number, viewMode?: GraphViewMode, userHiddenIds?: Set<string>): NodePositions;
+export declare function runForceSimulationStep(nodes: LineageNode[], edges: LineageEdge[], positions: NodePositions, disabledIds: Set<string>, width?: number, height?: number, centerGravity?: number, repulsionConstant?: number, springConstant?: number, restLength?: number, viewMode?: string): NodePositions;
+export declare function generateSvgLinkCurve(startX: number, startY: number, endX: number, endY: number, mode: string): string;

package/dist/workspace/utils/indexedDbHelper.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LineageNode, LineageEdge, LineagePayload } from "../types.js";
+export interface CachedDatasetMeta {
+    key: string;
+    nodesCount: number;
+    edgesCount: number;
+    generatedAt: string;
+}
+export interface SerializedIndices {
+    incoming: [string, string[]][];
+    outgoing: [string, string[]][];
+    edgeMap: [string, LineageEdge[]][];
+}
+/**
+ * Checks if a dataset is fully cached in IndexedDB
+ */
+export declare function isDatasetCached(key: string): Promise<boolean>;
+/**
+ * Save massive dataset and precomputed indices to IndexedDB
+ */
+export declare function saveDatasetToCache(key: string, payload: LineagePayload, indices: {
+    nodeMap: Map<string, LineageNode>;
+    incoming: Map<string, string[]>;
+    outgoing: Map<string, string[]>;
+    edgeMap: Map<string, LineageEdge[]>;
+}, onProgress?: (status: string, percent: number) => void): Promise<void>;
+/**
+ * Retrieve massive dataset and rebuild indices from IndexedDB cache
+ */
+export declare function loadDatasetFromCache(key: string, onProgress?: (status: string, percent: number) => void): Promise<{
+    payload: LineagePayload;
+    precomputedIndices: {
+        nodeMap: Map<string, LineageNode>;
+        incoming: Map<string, string[]>;
+        outgoing: Map<string, string[]>;
+        edgeMap: Map<string, LineageEdge[]>;
+    };
+} | null>;
+/**
+ * Remove cached items
+ */
+export declare function clearDatasetCache(key: string): Promise<void>;

package/dist/workspace/utils/mockData.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LineagePayload } from "../types";
+export declare const mockCoreRegistry: LineagePayload;
+export declare const mockDriftRegistry: LineagePayload;
+export declare function createLargeRegistry(): LineagePayload;
+export declare function createSuperLargeRegistry(): LineagePayload;
+export declare function createMegaScaleRegistry(): LineagePayload;