@sigloch/graph-api-core 0.4.0

package/dist/memory-adapter.js

@@ -0,0 +1,72 @@
+export class MemoryAdapter {
+    name = 'memory';
+    nodes = new Map();
+    edges = [];
+    async initialize() { }
+    async shutdown() {
+        this.nodes.clear();
+        this.edges = [];
+    }
+    async loadGraph(_scope) {
+        return {
+            nodes: Array.from(this.nodes.values()),
+            edges: [...this.edges],
+        };
+    }
+    async saveNodes(nodes) {
+        for (const node of nodes) {
+            this.nodes.set(node.uid, node);
+        }
+    }
+    async deleteNodes(uids) {
+        const uidSet = new Set(uids);
+        for (const uid of uids) {
+            this.nodes.delete(uid);
+        }
+        this.edges = this.edges.filter(e => !uidSet.has(e.sourceId) && !uidSet.has(e.targetId));
+    }
+    async saveEdges(edges) {
+        for (const edge of edges) {
+            // Upsert: remove existing with same key, then add
+            this.edges = this.edges.filter(e => !(e.sourceId === edge.sourceId && e.targetId === edge.targetId && e.edgeType === edge.edgeType));
+            this.edges.push(edge);
+        }
+    }
+    async deleteEdges(keys) {
+        const keySet = new Set(keys.map(k => `${k.sourceId}:${k.targetId}:${k.edgeType}`));
+        this.edges = this.edges.filter(e => !keySet.has(`${e.sourceId}:${e.targetId}:${e.edgeType}`));
+    }
+    async getNode(uid) {
+        return this.nodes.get(uid) ?? null;
+    }
+    async getSubgraph(root, depth) {
+        const visited = new Set();
+        const resultNodes = [];
+        const resultEdges = [];
+        const queue = [{ uid: root, d: 0 }];
+        while (queue.length > 0) {
+            const { uid, d } = queue.shift();
+            if (visited.has(uid))
+                continue;
+            visited.add(uid);
+            const node = this.nodes.get(uid);
+            if (node)
+                resultNodes.push(node);
+            if (d < depth) {
+                for (const edge of this.edges) {
+                    if (edge.sourceId === uid && !visited.has(edge.targetId)) {
+                        resultEdges.push(edge);
+                        queue.push({ uid: edge.targetId, d: d + 1 });
+                    }
+                }
+            }
+        }
+        return { nodes: resultNodes, edges: resultEdges };
+    }
+    async stats() {
+        return { nodeCount: this.nodes.size, edgeCount: this.edges.length };
+    }
+    async isHealthy() {
+        return true;
+    }
+}

package/dist/rule-engine.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pluggable rule engine for graph validation.
+ */
+import type { Graph } from './types.js';
+export interface RuleViolation {
+    ruleId: string;
+    ruleName: string;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    elementId?: string;
+    /** Carried from the contracts rule (CR-GC-203 item 1): how to fix this violation. */
+    fixHint?: string;
+    /** Carried from the contracts rule: candidate_targets / existing_traces context for fix automation. */
+    context?: unknown;
+}
+export interface Rule {
+    id: string;
+    name: string;
+    severity: 'error' | 'warning' | 'info';
+    evaluate: (graph: Graph) => RuleViolation[];
+}
+export interface RuleEngine {
+    readonly version: string;
+    register(rules: Rule[]): void;
+    evaluate(graph: Graph): RuleViolation[];
+}
+export declare class DefaultRuleEngine implements RuleEngine {
+    readonly version: string;
+    private rules;
+    constructor(version?: string);
+    register(rules: Rule[]): void;
+    evaluate(graph: Graph): RuleViolation[];
+}

package/dist/rule-engine.js

@@ -0,0 +1,17 @@
+export class DefaultRuleEngine {
+    version;
+    rules = [];
+    constructor(version = '1.0.0') {
+        this.version = version;
+    }
+    register(rules) {
+        this.rules.push(...rules);
+    }
+    evaluate(graph) {
+        const violations = [];
+        for (const rule of this.rules) {
+            violations.push(...rule.evaluate(graph));
+        }
+        return violations;
+    }
+}

package/dist/schemas.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Zod schemas for graph-api-core API types.
+ */
+import { z } from 'zod/v4';
+export declare const GraphNodeSchema: z.ZodObject<{
+    uid: z.ZodString;
+    type: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const GraphEdgeSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const GraphSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        type: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        targetId: z.ZodString;
+        edgeType: z.ZodString;
+        attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GraphScopeSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    systemId: z.ZodString;
+}, z.core.$strip>;
+export declare const GraphQuerySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        elements: "elements";
+        edges: "edges";
+        subgraph: "subgraph";
+        view: "view";
+    }>;
+    filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    view: z.ZodOptional<z.ZodString>;
+    root: z.ZodOptional<z.ZodString>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<{
+        json: "json";
+        "format-e": "format-e";
+    }>>;
+}, z.core.$strip>;
+export declare const RuleViolationSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+    ruleName: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+        info: "info";
+    }>;
+    message: z.ZodString;
+    elementId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MutationResultSchema: z.ZodObject<{
+    applied: z.ZodNumber;
+    rejected: z.ZodNumber;
+    violations: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        ruleName: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+            info: "info";
+        }>;
+        message: z.ZodString;
+        elementId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    version: z.ZodNumber;
+    auditId: z.ZodString;
+}, z.core.$strip>;
+export declare const HealthStatusSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        ok: "ok";
+        degraded: "degraded";
+        down: "down";
+    }>;
+    storage: z.ZodString;
+    ontologyName: z.ZodString;
+    ontologyVersion: z.ZodString;
+    elementCount: z.ZodNumber;
+    edgeCount: z.ZodNumber;
+    violationCount: z.ZodNumber;
+}, z.core.$strip>;

package/dist/schemas.js

@@ -0,0 +1,58 @@
+/**
+ * Zod schemas for graph-api-core API types.
+ */
+import { z } from 'zod/v4';
+export const GraphNodeSchema = z.object({
+    uid: z.string(),
+    type: z.string(),
+    name: z.string(),
+    description: z.string().optional(),
+    attributes: z.record(z.string(), z.unknown()).default({}),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+});
+export const GraphEdgeSchema = z.object({
+    sourceId: z.string(),
+    targetId: z.string(),
+    edgeType: z.string(),
+    attributes: z.record(z.string(), z.unknown()).default({}),
+});
+export const GraphSchema = z.object({
+    nodes: z.array(GraphNodeSchema),
+    edges: z.array(GraphEdgeSchema),
+});
+export const GraphScopeSchema = z.object({
+    workspaceId: z.string(),
+    systemId: z.string(),
+});
+export const GraphQuerySchema = z.object({
+    type: z.enum(['elements', 'edges', 'subgraph', 'view']),
+    filter: z.record(z.string(), z.unknown()).optional(),
+    view: z.string().optional(),
+    root: z.string().optional(),
+    depth: z.number().int().min(1).max(10).default(3),
+    format: z.enum(['json', 'format-e']).default('json'),
+});
+export const RuleViolationSchema = z.object({
+    ruleId: z.string(),
+    ruleName: z.string(),
+    severity: z.enum(['error', 'warning', 'info']),
+    message: z.string(),
+    elementId: z.string().optional(),
+});
+export const MutationResultSchema = z.object({
+    applied: z.number(),
+    rejected: z.number(),
+    violations: z.array(RuleViolationSchema),
+    version: z.number(),
+    auditId: z.string(),
+});
+export const HealthStatusSchema = z.object({
+    status: z.enum(['ok', 'degraded', 'down']),
+    storage: z.string(),
+    ontologyName: z.string(),
+    ontologyVersion: z.string(),
+    elementCount: z.number(),
+    edgeCount: z.number(),
+    violationCount: z.number(),
+});

package/dist/se-descriptor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SE OntologyDescriptor — derived from @sigloch/contracts/se (SSOT). [CR-195a]
+ *
+ * graph-api-core is ontology-agnostic; this is the canonical SE instance so
+ * consumers (aimprove, moneyflow, graphengine) share one ElementType/TraceType/
+ * Rule wiring instead of each rebuilding it (Drift-Lock L1/L2).
+ *
+ * Two shape gaps vs contracts/se are bridged here (it's an adapter, not a copy):
+ *   - Graph (nodes/edges)        ⟷  OntologyGraph (elements/traces)
+ *   - RuleViolation (ruleId/…)   ⟷  contracts RuleViolation (rule_id/…)
+ */
+import { type OntologyGraph } from '@sigloch/contracts/se';
+import type { Graph, OntologyDescriptor } from './types.js';
+/**
+ * Project an ontology-agnostic Graph (nodes/edges) onto the SE OntologyGraph
+ * (elements/traces) that contracts/se rules evaluate against. Type-specific
+ * attributes (asil/method/kinds/status) are lifted out of `attributes`.
+ */
+export declare function projectToOntologyGraph(graph: Graph): OntologyGraph;
+/**
+ * Canonical SE OntologyDescriptor (ontology + 17 rules), version-pinned to
+ * contracts/se ONTOLOGY_VERSION. Plug into GraphService / FormatECodec.
+ */
+export declare const SE_DESCRIPTOR: OntologyDescriptor;

package/dist/se-descriptor.js

@@ -0,0 +1,84 @@
+/**
+ * SE OntologyDescriptor — derived from @sigloch/contracts/se (SSOT). [CR-195a]
+ *
+ * graph-api-core is ontology-agnostic; this is the canonical SE instance so
+ * consumers (aimprove, moneyflow, graphengine) share one ElementType/TraceType/
+ * Rule wiring instead of each rebuilding it (Drift-Lock L1/L2).
+ *
+ * Two shape gaps vs contracts/se are bridged here (it's an adapter, not a copy):
+ *   - Graph (nodes/edges)        ⟷  OntologyGraph (elements/traces)
+ *   - RuleViolation (ruleId/…)   ⟷  contracts RuleViolation (rule_id/…)
+ */
+import { ElementType, TraceType, TRACE_PATTERNS, V3_RULES, ONTOLOGY_VERSION, } from '@sigloch/contracts/se';
+/**
+ * Project an ontology-agnostic Graph (nodes/edges) onto the SE OntologyGraph
+ * (elements/traces) that contracts/se rules evaluate against. Type-specific
+ * attributes (asil/method/kinds/status) are lifted out of `attributes`.
+ */
+export function projectToOntologyGraph(graph) {
+    const elements = graph.nodes.map((n) => ({
+        id: n.uid,
+        type: n.type,
+        name: n.name,
+        description: n.description ?? '',
+        status: n.attributes?.status ?? 'draft',
+        created_at: n.createdAt ?? '',
+        updated_at: n.updatedAt,
+        asil: n.attributes?.asil,
+        method: n.attributes?.method,
+        kinds: n.attributes?.kinds,
+        attributes: n.attributes,
+    }));
+    const traces = graph.edges.map((e) => ({
+        source: e.sourceId,
+        target: e.targetId,
+        type: e.edgeType,
+        category: e.attributes?.category,
+        label: e.attributes?.label,
+        weight: e.attributes?.weight ?? 1,
+        created_at: e.attributes?.created_at ?? '',
+        verified_at: e.attributes?.verified_at,
+        attributes: e.attributes,
+    }));
+    return { elements, traces };
+}
+/** The 17 contracts/se V3_RULES, adapted to graph-api-core's Rule shape. */
+const SE_RULES = V3_RULES.map((def) => ({
+    id: def.id,
+    name: def.name,
+    severity: def.severity,
+    evaluate: (graph) => def.evaluate(projectToOntologyGraph(graph)).map((v) => ({
+        ruleId: v.rule_id,
+        ruleName: def.name,
+        severity: v.severity,
+        message: v.message,
+        elementId: v.element_id,
+        // CR-GC-203 item 1: carry the fix-context through instead of discarding it,
+        // so rules_get_violations hands the agent candidates + a hint, not just a message.
+        fixHint: v.fix_hint,
+        context: v.context,
+    })),
+}));
+// `label` is the node-table identifier (kuzu table name) — must be a valid
+// identifier, so it's the ElementType key (SYS, UC, …), not the human
+// ELEMENT_DESCRIPTIONS text which would break DDL.
+const nodeTypes = Object.fromEntries(ElementType.options.map((t) => [t, { label: t, requiredAttrs: [] }]));
+const edgeTypes = Object.fromEntries(TraceType.options.map((tt) => {
+    const pairs = TRACE_PATTERNS.filter((p) => p.type === tt).map((p) => [p.source, p.target]);
+    // Types without an explicit pattern (e.g. generic 'relation') stay open.
+    return [tt, { arrows: [tt], validPairs: pairs.length ? pairs : [['*', '*']] }];
+}));
+/**
+ * Canonical SE OntologyDescriptor (ontology + 17 rules), version-pinned to
+ * contracts/se ONTOLOGY_VERSION. Plug into GraphService / FormatECodec.
+ */
+export const SE_DESCRIPTOR = {
+    name: 'se',
+    version: ONTOLOGY_VERSION,
+    nodeTypes,
+    edgeTypes,
+    // CR-GC-247: TRACE_PATTERNS is the trace-legality SSOT; validPairs above is kept
+    // only for Format-E arrow/menu enumeration. isValidTrace validates against these.
+    patterns: TRACE_PATTERNS,
+    rules: SE_RULES,
+};

package/dist/storage-adapter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * StorageAdapter interface — implemented by KuzuAdapter (@sigloch/graph-cypher-wasm), the one production store (Kuzu-only, 2yR-SSOT §Verriegelte Entscheidungen #3).
+ */
+import type { GraphNode, GraphEdge, Graph, GraphScope } from './types.js';
+export interface StorageAdapter {
+    readonly name: string;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    loadGraph(scope: GraphScope): Promise<Graph>;
+    saveNodes(nodes: GraphNode[]): Promise<void>;
+    deleteNodes(uids: string[]): Promise<void>;
+    saveEdges(edges: GraphEdge[]): Promise<void>;
+    deleteEdges(keys: Array<{
+        sourceId: string;
+        targetId: string;
+        edgeType: string;
+    }>): Promise<void>;
+    getNode(uid: string): Promise<GraphNode | null>;
+    /**
+     * Direction-aware subgraph around `root`.
+     *   - 'out'  (default): root's dependencies — `(root)-[*1..depth]->(m)` (back-compat).
+     *   - 'in'             : root's dependents / blast-radius — `(m)-[*1..depth]->(root)`.
+     *   - 'both'           : union of in + out.
+     * Adapters that do not implement direction MUST behave as 'out'.
+     */
+    getSubgraph(root: string, depth: number, direction?: 'out' | 'in' | 'both'): Promise<Graph>;
+    stats(): Promise<{
+        nodeCount: number;
+        edgeCount: number;
+    }>;
+    isHealthy(): Promise<boolean>;
+}

package/dist/storage-adapter.js

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

package/dist/test-fixtures.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Format-E test fixtures shipped with @sigloch/graph-api-core.
+ *
+ * Purpose: every consumer package (graph-renderer, graph-cypher-wasm,
+ * ontoagent-app, aise, flowground, …) loads these same fixtures in its test
+ * setup. Round-trip equality across consumers fences off Format-E drift sigloch-wide.
+ *
+ * Import:
+ *   import {
+ *     TEST_ONTOLOGY,
+ *     loadFixture,
+ *     FIXTURES,
+ *   } from '@sigloch/graph-api-core/test-fixtures';
+ */
+import type { OntologyDescriptor } from './types.js';
+import { FormatECodec } from './format-e-codec.js';
+export declare const TEST_ONTOLOGY: OntologyDescriptor;
+export declare const FIXTURES: {
+    readonly empty: "empty.format-e.md";
+    readonly rasentraktor: "rasentraktor.format-e.md";
+    readonly cr007Features: "cr-007-features.format-e.md";
+};
+export type FixtureName = keyof typeof FIXTURES;
+/**
+ * Read a fixture file from disk. Returns the raw markdown.
+ *
+ * For browser-only consumers, prefer `import.meta.glob` or a build-time
+ * inliner instead of this helper (Node fs is not available in the browser).
+ */
+export declare function readFixture(name: FixtureName): string;
+/**
+ * Read a fixture, extract the ```format-e fence, and parse it via the
+ * shipped FormatECodec + TEST_ONTOLOGY.
+ *
+ * Throws if the parse produces validation errors.
+ */
+export declare function loadFixture(name: FixtureName, codec?: FormatECodec): import("./types.js").FormatEDiff;
+/**
+ * Absolute path to the fixtures directory — useful for consumers using
+ * Vite's `?raw` import, esbuild's loader, or their own glob.
+ */
+export declare const FIXTURE_DIR_PATH: string;

package/dist/test-fixtures.js

@@ -0,0 +1,151 @@
+/**
+ * Format-E test fixtures shipped with @sigloch/graph-api-core.
+ *
+ * Purpose: every consumer package (graph-renderer, graph-cypher-wasm,
+ * ontoagent-app, aise, flowground, …) loads these same fixtures in its test
+ * setup. Round-trip equality across consumers fences off Format-E drift sigloch-wide.
+ *
+ * Import:
+ *   import {
+ *     TEST_ONTOLOGY,
+ *     loadFixture,
+ *     FIXTURES,
+ *   } from '@sigloch/graph-api-core/test-fixtures';
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { FormatECodec } from './format-e-codec.js';
+// ---------------------------------------------------------------------------
+// Minimal test ontology
+// ---------------------------------------------------------------------------
+// Mirrors the node/edge taxonomy used by the ontoagent workshop assistant
+// (OU, R, PR, VAR, MT, SL, C, F, FR, CTRL, TC, TL …) — enough to parse the
+// shipped fixtures without forcing consumers to define their own descriptor.
+// Consumers with a richer ontology should compose this with their own.
+export const TEST_ONTOLOGY = {
+    name: 'sigloch-test-ontology',
+    version: '0.1.0',
+    nodeTypes: {
+        OU: { label: 'OrgUnit', requiredAttrs: [] },
+        R: { label: 'Role', requiredAttrs: [] },
+        PR: { label: 'Product', requiredAttrs: [] },
+        VAR: { label: 'Variant', requiredAttrs: [] },
+        C: { label: 'Component', requiredAttrs: [] },
+        F: { label: 'Feature', requiredAttrs: [] },
+        FR: { label: 'FmeaRow', requiredAttrs: [] },
+        CTRL: { label: 'Control', requiredAttrs: [] },
+        TC: { label: 'TestCase', requiredAttrs: [] },
+        TL: { label: 'Tool', requiredAttrs: [] },
+        MT: { label: 'MilestoneType', requiredAttrs: [] },
+        SL: { label: 'StorageLocation', requiredAttrs: [] },
+    },
+    edgeTypes: {
+        compose: {
+            arrows: ['compose'],
+            validPairs: [
+                ['PR', 'C'],
+                ['C', 'C'],
+            ],
+        },
+        has_variant: {
+            arrows: ['has_variant'],
+            validPairs: [
+                ['PR', 'VAR'],
+            ],
+        },
+        realized_by: {
+            arrows: ['realized_by'],
+            validPairs: [
+                ['F', 'C'],
+            ],
+        },
+        addressed_by: {
+            arrows: ['addressed_by'],
+            validPairs: [
+                ['C', 'FR'],
+                ['FR', 'CTRL'],
+                ['C', 'C'],
+            ],
+        },
+        verified_by: {
+            arrows: ['verified_by'],
+            validPairs: [
+                ['CTRL', 'TC'],
+                ['FR', 'TC'],
+            ],
+        },
+        responsible_for: {
+            arrows: ['responsible_for'],
+            validPairs: [
+                ['OU', 'C'],
+                ['OU', 'TL'],
+                ['R', 'C'],
+                ['R', 'TL'],
+            ],
+        },
+        within: {
+            arrows: ['within'],
+            validPairs: [
+                ['R', 'OU'],
+            ],
+        },
+        requires_document_of_type: {
+            arrows: ['requires_document_of_type'],
+            validPairs: [
+                ['MT', 'FR'],
+            ],
+        },
+        stored_in: {
+            arrows: ['stored_in'],
+            validPairs: [
+                ['C', 'SL'],
+                ['FR', 'SL'],
+            ],
+        },
+    },
+};
+// ---------------------------------------------------------------------------
+// Fixture loader
+// ---------------------------------------------------------------------------
+// Resolves to <package-root>/test-fixtures whether loaded from src/ (vitest) or dist/ (consumers).
+const FIXTURE_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'test-fixtures');
+export const FIXTURES = {
+    empty: 'empty.format-e.md',
+    rasentraktor: 'rasentraktor.format-e.md',
+    cr007Features: 'cr-007-features.format-e.md',
+};
+/**
+ * Read a fixture file from disk. Returns the raw markdown.
+ *
+ * For browser-only consumers, prefer `import.meta.glob` or a build-time
+ * inliner instead of this helper (Node fs is not available in the browser).
+ */
+export function readFixture(name) {
+    return readFileSync(join(FIXTURE_DIR, FIXTURES[name]), 'utf8');
+}
+/**
+ * Read a fixture, extract the ```format-e fence, and parse it via the
+ * shipped FormatECodec + TEST_ONTOLOGY.
+ *
+ * Throws if the parse produces validation errors.
+ */
+export function loadFixture(name, codec) {
+    const raw = readFixture(name);
+    const c = codec ?? new FormatECodec(TEST_ONTOLOGY);
+    const fence = c.extractFromLlm(raw);
+    if (fence === null && name !== 'empty') {
+        throw new Error(`Fixture ${name} has no \`\`\`format-e fence`);
+    }
+    const body = fence ?? '';
+    const diff = c.parse(body);
+    if (diff.errors.length > 0) {
+        throw new Error(`Fixture ${name} parse errors:\n  - ${diff.errors.join('\n  - ')}`);
+    }
+    return diff;
+}
+/**
+ * Absolute path to the fixtures directory — useful for consumers using
+ * Vite's `?raw` import, esbuild's loader, or their own glob.
+ */
+export const FIXTURE_DIR_PATH = FIXTURE_DIR;

package/dist/testing/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared contract test suites for StorageAdapter and TransportAdapter.
+ * Import from '@sigloch/graph-api-core/testing'
+ *
+ * Usage:
+ * ```ts
+ * import { runStorageContractTests } from '@sigloch/graph-api-core/testing'
+ * runStorageContractTests(() => new MyAdapter())
+ * ```
+ */
+export { runStorageContractTests } from './storage-contract-tests.js';

package/dist/testing/index.js

@@ -0,0 +1,11 @@
+/**
+ * Shared contract test suites for StorageAdapter and TransportAdapter.
+ * Import from '@sigloch/graph-api-core/testing'
+ *
+ * Usage:
+ * ```ts
+ * import { runStorageContractTests } from '@sigloch/graph-api-core/testing'
+ * runStorageContractTests(() => new MyAdapter())
+ * ```
+ */
+export { runStorageContractTests } from './storage-contract-tests.js';

package/dist/testing/storage-contract-tests.d.ts

@@ -0,0 +1,2 @@
+import type { StorageAdapter } from '../storage-adapter.js';
+export declare function runStorageContractTests(factory: () => StorageAdapter | Promise<StorageAdapter>): void;