@ontologie/mock-server 0.1.0-preview.1

package/dist/server.js

@@ -0,0 +1,1282 @@
+/**
+ * MockServer — in-memory DataForge API mock.
+ *
+ * Covers M1-M7 SDK features: ontology, knowledge, agent, dashboard,
+ * calendar CRUD, audit export, forms, scenarios, decision-compare.
+ */
+import { createServer } from 'node:http';
+import { defaultFixtures } from './fixtures.js';
+export class MockServer {
+    objects;
+    edges;
+    latencyMs;
+    idCounter = 1000;
+    constructor(options) {
+        // Bug 33 fix: Deep-clone fixtures to prevent mutation of defaults
+        this.objects = MockServer.cloneObjectMap(options?.fixtures?.objects ?? defaultFixtures.objects);
+        this.edges = MockServer.cloneEdges(options?.fixtures?.edges ?? defaultFixtures.edges);
+        this.latencyMs = options?.latencyMs ?? 0;
+    }
+    static cloneObjectMap(source) {
+        const cloned = new Map();
+        for (const [key, arr] of source) {
+            cloned.set(key, arr.map(obj => ({ ...obj })));
+        }
+        return cloned;
+    }
+    static cloneEdges(source) {
+        return source.map(e => ({ ...e }));
+    }
+    get url() {
+        return 'http://mock.dataforge.local';
+    }
+    /** Create a fetch function that routes to this mock server. */
+    createFetch() {
+        return async (input, init) => {
+            if (this.latencyMs > 0) {
+                await new Promise(r => setTimeout(r, this.latencyMs));
+            }
+            // Bug 34 fix: Handle Request objects (input instanceof Request)
+            const url = input instanceof Request ? input.url : String(input);
+            const method = (init?.method ?? (input instanceof Request ? input.method : undefined) ?? 'GET').toUpperCase();
+            // Extract path using URL parsing — avoids host-dependent string replace
+            let path;
+            try {
+                const parsed = new URL(url);
+                path = parsed.pathname;
+            }
+            catch {
+                path = url.replace(this.url, '');
+            }
+            const body = init?.body ? JSON.parse(init.body) : undefined;
+            return this.route(method, path, body);
+        };
+    }
+    async listen(options = {}) {
+        const host = options.host ?? '127.0.0.1';
+        const requestedPort = options.port ?? 8787;
+        const fetchFn = this.createFetch();
+        const httpServer = createServer((req, res) => {
+            void this.handleHttpRequest(req, res, host, requestedPort, fetchFn);
+        });
+        await new Promise((resolve, reject) => {
+            httpServer.once('error', reject);
+            httpServer.listen(requestedPort, host, () => {
+                httpServer.off('error', reject);
+                resolve();
+            });
+        });
+        const address = httpServer.address();
+        const port = typeof address === 'object' && address ? address.port : requestedPort;
+        const url = `http://${host}:${port}`;
+        return {
+            url,
+            host,
+            port,
+            server: httpServer,
+            close: () => new Promise((resolve, reject) => {
+                httpServer.close((err) => err ? reject(err) : resolve());
+            }),
+        };
+    }
+    async handleHttpRequest(req, res, host, fallbackPort, fetchFn) {
+        try {
+            const chunks = [];
+            for await (const chunk of req) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            const body = chunks.length > 0 ? Buffer.concat(chunks).toString('utf-8') : undefined;
+            const requestHost = req.headers.host ?? `${host}:${fallbackPort}`;
+            const response = await fetchFn(`http://${requestHost}${req.url ?? '/'}`, {
+                method: req.method ?? 'GET',
+                headers: req.headers,
+                ...(body ? { body } : {}),
+            });
+            res.statusCode = response.status;
+            response.headers.forEach((value, key) => {
+                res.setHeader(key, value);
+            });
+            const buffer = Buffer.from(await response.arrayBuffer());
+            res.end(buffer);
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({
+                error: {
+                    code: 'MOCK_HTTP_SERVER_ERROR',
+                    message: error instanceof Error ? error.message : 'Mock HTTP server error',
+                },
+            }));
+        }
+    }
+    route(method, path, body) {
+        // Health
+        if (path === '/api/v1/admin/health' || path === '/health') {
+            return this.json({ status: 'healthy', version: 'mock-1.0.0' });
+        }
+        // 6B: Query objects with filter/order/limit support
+        if (method === 'POST' && path === '/api/v1/ontology/query') {
+            const objectType = body?.objectType;
+            let objects = [...(this.objects.get(objectType) ?? [])];
+            // Apply filters — accept both body.filters (SDK sends this) and body.where (legacy)
+            const filterObj = body?.filters ?? body?.where;
+            if (filterObj && typeof filterObj === 'object') {
+                for (const [field, condition] of Object.entries(filterObj)) {
+                    if (condition && typeof condition === 'object') {
+                        if ('eq' in condition)
+                            objects = objects.filter(o => o[field] === condition.eq);
+                        if ('neq' in condition)
+                            objects = objects.filter(o => o[field] !== condition.neq);
+                        if ('gt' in condition)
+                            objects = objects.filter(o => o[field] > condition.gt);
+                        if ('gte' in condition)
+                            objects = objects.filter(o => o[field] >= condition.gte);
+                        if ('lt' in condition)
+                            objects = objects.filter(o => o[field] < condition.lt);
+                        if ('lte' in condition)
+                            objects = objects.filter(o => o[field] <= condition.lte);
+                        if ('contains' in condition)
+                            objects = objects.filter(o => String(o[field] ?? '').includes(String(condition.contains)));
+                    }
+                    else {
+                        // Direct equality shorthand
+                        objects = objects.filter(o => o[field] === condition);
+                    }
+                }
+            }
+            // Apply orderBy — handles both object { field: 'asc'|'desc' } and array [{ field, direction }]
+            const orderBy = body?.orderBy;
+            if (orderBy) {
+                let field;
+                let dir;
+                if (Array.isArray(orderBy) && orderBy.length > 0) {
+                    field = orderBy[0].field;
+                    dir = orderBy[0].direction === 'desc' ? -1 : 1;
+                }
+                else if (typeof orderBy === 'object') {
+                    field = Object.keys(orderBy)[0];
+                    dir = orderBy[field] === 'desc' ? -1 : 1;
+                }
+                else {
+                    field = '';
+                    dir = 1;
+                }
+                if (field) {
+                    objects.sort((a, b) => {
+                        const va = a[field], vb = b[field];
+                        if (va == null && vb == null)
+                            return 0;
+                        if (va == null)
+                            return dir;
+                        if (vb == null)
+                            return -dir;
+                        return va < vb ? -dir : va > vb ? dir : 0;
+                    });
+                }
+            }
+            const total = objects.length;
+            const offset = body?.offset ?? 0;
+            // Apply limit/offset
+            if (body?.limit)
+                objects = objects.slice(offset, offset + body.limit);
+            else if (body?.pageSize)
+                objects = objects.slice(0, body.pageSize);
+            // hasMore: are there remaining items beyond this page?
+            return this.json({ data: objects, total, hasMore: (offset + objects.length) < total });
+        }
+        // Bug 35 fix: GET /api/v1/object-types/:apiName/instances — list instances
+        const instanceListMatch = path.match(/^\/api\/v1\/object-types\/([^/]+)\/instances$/);
+        if (method === 'GET' && instanceListMatch) {
+            const [, objectType] = instanceListMatch;
+            const objects = this.objects.get(objectType) ?? [];
+            return this.json({ success: true, data: objects, total: objects.length, hasMore: false });
+        }
+        // Bug 35 fix: GET /api/v1/instances/:id — get single instance
+        const instanceGetMatch = path.match(/^\/api\/v1\/instances\/([^/]+)$/);
+        if (method === 'GET' && instanceGetMatch) {
+            const [, instanceId] = instanceGetMatch;
+            for (const [objectType, list] of this.objects) {
+                const obj = list.find(o => o.$primaryKey === instanceId);
+                if (obj) {
+                    return this.json({
+                        success: true,
+                        data: {
+                            id: instanceId,
+                            object_type_id: objectType,
+                            data: { ...obj },
+                            version: obj.$version,
+                            status: 'active',
+                            source_type: 'manual',
+                            external_id: null,
+                            created_at: new Date().toISOString(),
+                            updated_at: new Date().toISOString(),
+                        },
+                    });
+                }
+            }
+            return this.json({ success: false, error: { code: 'INSTANCE_NOT_FOUND', message: `Instance '${instanceGetMatch[1]}' not found` } }, 404);
+        }
+        // Get object by ID (legacy ontology route)
+        const getMatch = path.match(/^\/api\/v1\/ontology\/(\w+)\/(.+)$/);
+        if (method === 'GET' && getMatch) {
+            const [, objectType, id] = getMatch;
+            const objects = this.objects.get(objectType) ?? [];
+            const obj = objects.find(o => o.$primaryKey === id);
+            if (!obj)
+                return this.json({ message: 'Not found' }, 404);
+            return this.json(obj);
+        }
+        // Create object
+        const createMatch = path.match(/^\/api\/v1\/ontology\/(\w+)$/);
+        if (method === 'POST' && createMatch && body) {
+            const [, objectType] = createMatch;
+            const newObj = {
+                $primaryKey: `mock-${++this.idCounter}`,
+                $objectType: objectType,
+                $version: 1,
+                ...body,
+            };
+            if (!this.objects.has(objectType))
+                this.objects.set(objectType, []);
+            this.objects.get(objectType).push(newObj);
+            return this.json(newObj, 201);
+        }
+        // 6A: GET /api/v1/ontology/manifest — full manifest
+        if (method === 'GET' && path === '/api/v1/ontology/manifest') {
+            return this.json({
+                version: '1.0',
+                generatedAt: new Date().toISOString(),
+                workspaceId: 'mock-workspace',
+                espaceId: '',
+                objectTypes: defaultFixtures.objectTypes.map((t) => ({
+                    id: `mock-${t.apiName}`,
+                    apiName: t.apiName,
+                    displayName: t.displayName,
+                    description: t.description ?? '',
+                    status: 'active',
+                    properties: t.properties ?? [],
+                })),
+                linkTypes: defaultFixtures.linkTypes.map((l) => ({
+                    id: `mock-link-${l.apiName}`,
+                    apiName: l.apiName,
+                    sourceTypeApiName: l.sourceTypeApiName,
+                    targetTypeApiName: l.targetTypeApiName,
+                    cardinality: l.cardinality,
+                    relationshipType: l.relationshipType ?? l.apiName,
+                    label: l.displayName,
+                    inverseName: l.inverseName,
+                    properties: [],
+                })),
+                interfaces: [],
+                actions: [],
+            });
+        }
+        // 6A: GET /api/v1/ontology/manifest/version — version hash
+        if (method === 'GET' && path === '/api/v1/ontology/manifest/version') {
+            return this.json({ version: 'mock-v1-hash' });
+        }
+        // List object types (manifest)
+        if (method === 'GET' && path === '/api/v1/ontology/types') {
+            return this.json({ data: defaultFixtures.objectTypes });
+        }
+        // List link types
+        if (method === 'GET' && path === '/api/v1/ontology/link-types') {
+            return this.json({ data: defaultFixtures.linkTypes });
+        }
+        // Raw nodes endpoint — used by `dataforge schema export` and `schema pull`
+        // (`sdk/packages/cli/src/commands/schema.ts:82,150`). Returns ObjectType
+        // and LinkType nodes in the shape the CLI normalizes into a manifest.
+        // Locked by `tests/structural/sdk-cli-parity.test.ts` C4 parity sample.
+        //
+        // Important: ObjectType.properties and LinkType.properties have
+        // **different shapes** by design (mirrors staging behaviour):
+        //   - ObjectType.properties = array of property descriptors
+        //     (`[{ apiName, dataType, required, ... }]`).
+        //   - LinkType.properties   = metadata object describing the relation
+        //     (`{ sourceTypeApiName, targetTypeApiName, cardinality,
+        //         inverseName }`).
+        // The CLI normalizer (`commands/schema.ts:103-114`) branches on
+        // `node.type === 'LinkType'` before touching `properties`, so the
+        // divergence is intentional. Don't unify here without first updating
+        // the CLI normalizer (review feedback #992 minor b).
+        if (method === 'GET' && path.startsWith('/api/v2/queries/nodes')) {
+            const objectTypeNodes = defaultFixtures.objectTypes.map((t) => ({
+                id: `mock-${t.apiName}`,
+                name: t.apiName,
+                displayName: t.displayName,
+                description: t.description ?? '',
+                type: 'ObjectType',
+                properties: t.properties ?? [],
+                groups: [],
+                interfaces: [],
+                primaryKey: t.properties?.[0]?.apiName ?? null,
+                status: 'active',
+                api_name: t.apiName,
+                rid: `rid-mock-${t.apiName}`,
+            }));
+            const linkTypeNodes = defaultFixtures.linkTypes.map((l) => ({
+                id: `mock-link-${l.apiName}`,
+                name: l.apiName,
+                displayName: l.displayName ?? l.apiName,
+                description: '',
+                type: 'LinkType',
+                properties: {
+                    sourceTypeApiName: l.sourceTypeApiName,
+                    targetTypeApiName: l.targetTypeApiName,
+                    cardinality: l.cardinality ?? 'N:1',
+                    inverseName: l.inverseName,
+                },
+                groups: [],
+                interfaces: [],
+                primaryKey: null,
+                status: 'active',
+                api_name: l.apiName,
+                rid: `rid-mock-link-${l.apiName}`,
+                sourceId: l.sourceTypeApiName,
+                targetId: l.targetTypeApiName,
+            }));
+            const data = [...objectTypeNodes, ...linkTypeNodes];
+            return this.json({ success: true, data, count: data.length });
+        }
+        // Instance graph — traverse edges from a source
+        const graphTraverseMatch = path.match(/^\/api\/v1\/instance-graph\/([^/]+)\/traverse$/);
+        if (method === 'POST' && graphTraverseMatch) {
+            const sourceKey = graphTraverseMatch[1];
+            const linkType = body?.linkType;
+            const matching = this.edges.filter(e => e.sourceKey === sourceKey && (!linkType || e.linkType === linkType));
+            const targetKeys = matching.map(e => e.targetKey);
+            const targets = [];
+            for (const [, objs] of this.objects) {
+                for (const obj of objs) {
+                    if (targetKeys.includes(obj.$primaryKey))
+                        targets.push(obj);
+                }
+            }
+            return this.json({ data: targets, total: targets.length, hasMore: false });
+        }
+        // Instance graph — neighbors (both directions)
+        const graphNeighborsMatch = path.match(/^\/api\/v1\/instance-graph\/([^/]+)\/neighbors$/);
+        if (method === 'GET' && graphNeighborsMatch) {
+            const key = graphNeighborsMatch[1];
+            const neighborKeys = new Set();
+            for (const e of this.edges) {
+                if (e.sourceKey === key)
+                    neighborKeys.add(e.targetKey);
+                if (e.targetKey === key)
+                    neighborKeys.add(e.sourceKey);
+            }
+            const neighbors = [];
+            for (const [, objs] of this.objects) {
+                for (const obj of objs) {
+                    if (neighborKeys.has(obj.$primaryKey))
+                        neighbors.push(obj);
+                }
+            }
+            return this.json({ data: neighbors, total: neighbors.length, hasMore: false });
+        }
+        // ── V1 Graph SOT (PR #1003 — GraphReadService) ────────────────────
+        //
+        // These three routes mirror the real backend's GraphReadService envelope
+        // (`{ data, meta }` per `buildV1Envelope`) so SDK clients calling
+        // `GraphOperations.{traverse,neighbors,shortestPath}` can hit either
+        // staging or this mock with identical behaviour.
+        // Data shapes match `GraphTraversalResult`, `GraphNeighborsResult`,
+        // `ShortestPathResult` in `@dataforge/sdk-types/graph.ts`.
+        // POST /api/v1/graph/traverse — bounded BFS from startNodeId
+        if (method === 'POST' && path === '/api/v1/graph/traverse') {
+            const startNodeId = body?.startNodeId ?? body?.startNode ?? '';
+            const requestedDepth = Number(body?.maxDepth ?? 2);
+            const direction = body?.direction ?? 'any';
+            const traversal = this.traverseGraph(startNodeId, requestedDepth, direction);
+            return this.json(this.v1Envelope(traversal, {
+                operation: 'traverse',
+                requestedDepth,
+                effectiveDepth: traversal.totalDepth,
+                truncated: traversal.truncated,
+            }));
+        }
+        // GET /api/v1/graph/neighbors/:id — direct neighbours (bounded)
+        const v1NeighborsMatch = path.match(/^\/api\/v1\/graph\/neighbors\/([^/?]+)(?:\?.*)?$/);
+        if (method === 'GET' && v1NeighborsMatch) {
+            const nodeId = decodeURIComponent(v1NeighborsMatch[1]);
+            const result = this.neighborsOf(nodeId);
+            return this.json(this.v1Envelope(result, {
+                operation: 'neighbors',
+                truncated: false,
+            }));
+        }
+        // POST /api/v1/graph/paths — shortest path (BFS over in-memory edges)
+        if (method === 'POST' && path === '/api/v1/graph/paths') {
+            const sourceId = body?.sourceId ?? '';
+            const targetId = body?.targetId ?? '';
+            const maxHops = Number(body?.maxHops ?? body?.maxDepth ?? 5);
+            const result = this.shortestPathBetween(sourceId, targetId, maxHops);
+            return this.json(this.v1Envelope(result, {
+                operation: 'shortestPath',
+                requestedHops: maxHops,
+                effectiveHops: result.path?.length ? result.path.length - 1 : 0,
+                truncated: false,
+            }));
+        }
+        // ── V1 Action SOT (action SOT wedge 2026-04-29) ───────────────────
+        //
+        // Mirrors the real backend's ActionReadService envelope (`{ data: { action,
+        // diagnostics }, meta }` per `buildV1Envelope`) so SDK clients calling the
+        // V1 describe endpoint can hit either staging or this mock with identical
+        // behaviour. Locked by ratchet `ACTION-ENVELOPE-V1-01`.
+        // GET /api/v1/actions/:action_key/describe — single action descriptor
+        const actionDescribeMatch = path.match(/^\/api\/v1\/actions\/([^/?]+)\/describe(?:\?.*)?$/);
+        if (method === 'GET' && actionDescribeMatch) {
+            const actionKey = decodeURIComponent(actionDescribeMatch[1]);
+            // Mock action descriptor — minimal but realistic shape matching the
+            // ActionDescriptor type in `services/actions/types.ts`.
+            const nowIso = new Date().toISOString();
+            const descriptor = {
+                action: {
+                    id: `mock-action-${actionKey}`,
+                    entityId: 'mock-entity-id',
+                    espaceId: null,
+                    apiName: actionKey,
+                    name: actionKey,
+                    displayName: `Mock action ${actionKey}`,
+                    description: 'Mock action returned by @dataforge/mock-server',
+                    actionType: 'TRANSFORM',
+                    trigger: null,
+                    implementationType: 'builtin',
+                    status: 'ACTIVE',
+                    objectType: 'MockObject',
+                    parameters: [],
+                    preconditions: [],
+                    effects: [],
+                    requiredScopes: ['actions.run'],
+                    limits: {
+                        maxObjectsTouched: 20,
+                        timeoutMs: 30000,
+                        externalIO: false,
+                    },
+                    inputMapping: null,
+                    outputMapping: null,
+                    retryConfig: null,
+                    awaitCompletion: true,
+                    workflowId: null,
+                    agentId: null,
+                    createdAt: nowIso,
+                    updatedAt: nowIso,
+                },
+            };
+            return this.json(this.v1Envelope(descriptor, {
+                operation: 'describe',
+                truncated: false,
+            }));
+        }
+        // ── V1 Core Loop handlers (D-SDK-ALIGN-1) ────────────────────────
+        // POST /api/v1/context/pack — context compiler (Discover verb)
+        if (method === 'POST' && path === '/api/v1/context/pack') {
+            const query = body?.query ?? '';
+            return this.json({
+                query,
+                budget: { requested: body?.budget ?? 4000, used: 1200 },
+                sections: {
+                    ontology: { summary: 'Mock ontology context', entities: [], stats: {} },
+                },
+                timing_ms: 42,
+                request_id: `mock-ctx-${++this.idCounter}`,
+            });
+        }
+        // GET /api/v1/search/global — federated search (Search verb)
+        if (method === 'GET' && path === '/api/v1/search/global') {
+            return this.json({
+                success: true,
+                data: [],
+                meta: { total: 0 },
+            });
+        }
+        // POST /api/v1/graph/constrained-search — graph constrained search
+        if (method === 'POST' && path === '/api/v1/graph/constrained-search') {
+            return this.json(this.v1Envelope({ results: [], totalCount: 0 }, {
+                operation: 'traverse',
+                truncated: false,
+            }));
+        }
+        // GET /api/v1/plans — list plans (Inspect verb)
+        if (method === 'GET' && path === '/api/v1/plans') {
+            return this.json({ success: true, data: [] });
+        }
+        // GET /api/v1/plans/:id — get plan by ID
+        const planGetMatch = path.match(/^\/api\/v1\/plans\/([^/]+)$/);
+        if (method === 'GET' && planGetMatch) {
+            const planId = decodeURIComponent(planGetMatch[1]);
+            return this.json({
+                success: true,
+                data: {
+                    artifactVersion: '1',
+                    planId,
+                    planHash: `mock-hash-${planId}`,
+                    signature: { algorithm: 'mock', keyId: 'mock-key', signed: 'mock', value: 'mock', trustLevel: 'local_mock' },
+                    body: {
+                        planSchemaVersion: '1', planId, createdAt: new Date().toISOString(),
+                        expiresAt: new Date(Date.now() + 300_000).toISOString(), ttlSeconds: 300,
+                        workspace: { workspaceId: 'mock-ws' }, operation: { kind: 'action' },
+                        actor: { initiator: { principalType: 'user', principalId: 'mock-user' }, credential: 'mock', applyBinding: 'mock' },
+                        versions: {}, authorization: { requiredScopes: [], grantedScopes: [] }, inputs: {},
+                        dependencies: { targetVersions: {}, readVersions: {}, expectedAbsent: [] },
+                        effects: [], policyChecks: [], risk: { level: 'low', requiresConfirmation: false, reasonCodes: [] },
+                        applyConstraints: {},
+                    },
+                    state: { status: 'ready' },
+                    redaction: { mode: 'none', redactedPaths: [] },
+                    meta: {},
+                },
+            });
+        }
+        // POST /api/v1/plans/:id/verify — verify plan
+        const planVerifyMatch = path.match(/^\/api\/v1\/plans\/([^/]+)\/verify$/);
+        if (method === 'POST' && planVerifyMatch) {
+            const planId = decodeURIComponent(planVerifyMatch[1]);
+            return this.json({
+                success: true,
+                data: {
+                    planId,
+                    planHash: `mock-hash-${planId}`,
+                    signatureValid: true,
+                    storedBodyHashValid: true,
+                    state: { status: 'ready' },
+                    computedStatus: 'ready',
+                    canApply: true,
+                    checks: [{ name: 'signature', status: 'passed' }],
+                },
+            });
+        }
+        // GET /api/v1/usage/me — workspace usage (Measure verb)
+        if (method === 'GET' && path === '/api/v1/usage/me') {
+            return this.json({
+                plan: 'free',
+                costUnitsUsed: 42,
+                costUnitsLimit: 1000,
+                remainingBudget: 958,
+                periodStart: new Date(new Date().getFullYear(), new Date().getMonth(), 1).toISOString(),
+                periodEnd: new Date(new Date().getFullYear(), new Date().getMonth() + 1, 0).toISOString(),
+                rateLimits: { source: 'plan_config', readPerMinute: 60, writePerMinute: 30, burstPerSecond: 10 },
+            });
+        }
+        // GET /api/v1/usage/forecast — usage forecast
+        if (method === 'GET' && path === '/api/v1/usage/forecast') {
+            return this.json({
+                consumed: 42,
+                projected: 126,
+                limit: 1000,
+                remainingBudget: 958,
+                percentOfBudget: 13,
+                daysElapsed: 10,
+                daysInMonth: 30,
+            });
+        }
+        // Knowledge search
+        if (method === 'POST' && path === '/api/v1/knowledge/search') {
+            return this.json({ data: [], total: 0 });
+        }
+        // Agent invoke
+        if (method === 'POST' && path === '/api/v1/agent/invoke') {
+            return this.json({
+                answer: `Mock response to: ${body?.query}`,
+                confidence: 0.85,
+                conversationId: 'mock-conv-1',
+            });
+        }
+        // ── Dashboard ──────────────────────────────────────────────────────
+        // Dashboard KPIs
+        if (path === '/api/dashboard/summary') {
+            // D-SDK-ROUTES-FIX R8: return summary shape that matches backend
+            return this.json({
+                ontology: { objectTypes: 5, linkTypes: 3, instances: 42 },
+                workflow: { active: 2, completed: 10 },
+                agent: { sessions: 3, invocations: 25 },
+                apiManager: { apis: 1 },
+            });
+        }
+        // Dashboard trends
+        if (method === 'GET' && path === '/api/dashboard/trends') {
+            return this.json(defaultFixtures.dashboardTimeseries);
+        }
+        // Dashboard analytics (ontology summary)
+        if (method === 'GET' && path === '/api/dashboard/ontology-summary') {
+            return this.json(defaultFixtures.dashboardStats);
+        }
+        // ── Calendar CRUD ──────────────────────────────────────────────────
+        // List calendar events
+        if (method === 'GET' && path === '/api/v1/calendar/events') {
+            return this.json({ data: defaultFixtures.calendarEvents, cursor: undefined, hasMore: false });
+        }
+        // Get calendar event by ID
+        const calGetMatch = path.match(/^\/api\/v1\/calendar\/events\/([^/]+)$/);
+        if (method === 'GET' && calGetMatch) {
+            return this.json(defaultFixtures.calendarEvents[0]);
+        }
+        // Create calendar event
+        if (method === 'POST' && path === '/api/v1/calendar/events') {
+            const now = new Date().toISOString();
+            return this.json({
+                id: `evt-${++this.idCounter}`,
+                calendarId: 'cal-001',
+                title: body?.title ?? 'New Event',
+                startTime: body?.startTime ?? now,
+                endTime: body?.endTime ?? now,
+                allDay: body?.allDay ?? false,
+                recurrence: body?.recurrence ?? null,
+                createdAt: now,
+            }, 201);
+        }
+        // Update calendar event
+        const calPutMatch = path.match(/^\/api\/v1\/calendar\/events\/([^/]+)$/);
+        if (method === 'PUT' && calPutMatch) {
+            return this.json({
+                ...defaultFixtures.calendarEvents[0],
+                id: calPutMatch[1],
+                ...body,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        // Delete calendar event
+        const calDelMatch = path.match(/^\/api\/v1\/calendar\/events\/([^/]+)$/);
+        if (method === 'DELETE' && calDelMatch) {
+            return this.json(null, 204);
+        }
+        // ── Audit ──────────────────────────────────────────────────────────
+        // Audit events list
+        if (method === 'GET' && path === '/api/v1/audit/events') {
+            return this.json({ data: defaultFixtures.auditEvents, cursor: undefined, hasMore: false });
+        }
+        // Audit event by ID
+        const auditGetMatch = path.match(/^\/api\/v1\/audit\/events\/([^/]+)$/);
+        if (method === 'GET' && auditGetMatch) {
+            return this.json(defaultFixtures.auditEvents[0]);
+        }
+        // Audit entity history
+        const auditHistMatch = path.match(/^\/api\/v1\/audit\/entities\/([^/]+)\/([^/]+)\/history$/);
+        if (method === 'GET' && auditHistMatch) {
+            return this.json({ data: defaultFixtures.auditEvents, cursor: undefined, hasMore: false });
+        }
+        // Audit export
+        if (method === 'POST' && path === '/api/v1/audit/export') {
+            return this.json({
+                downloadUrl: 'https://storage.dataforge.local/exports/audit-export-001.csv',
+                expiresAt: '2026-04-20T00:00:00Z',
+            });
+        }
+        // ── Forms ──────────────────────────────────────────────────────────
+        // List forms
+        if (method === 'GET' && path === '/api/v1/forms') {
+            return this.json({ data: defaultFixtures.forms });
+        }
+        // Get form by ID
+        const formGetMatch = path.match(/^\/api\/v1\/forms\/([^/]+)$/);
+        if (method === 'GET' && formGetMatch) {
+            return this.json({ data: defaultFixtures.forms[0] });
+        }
+        // Create form
+        if (method === 'POST' && path === '/api/v1/forms') {
+            const now = new Date().toISOString();
+            return this.json({ data: {
+                    id: `form-${++this.idCounter}`,
+                    name: body?.name ?? 'New Form',
+                    description: body?.description ?? '',
+                    status: 'draft',
+                    fields: body?.fields ?? [],
+                    submitCount: 0,
+                    createdAt: now,
+                    updatedAt: now,
+                } }, 201);
+        }
+        // Submit to form
+        const formSubmitMatch = path.match(/^\/api\/v1\/forms\/([^/]+)\/submit$/);
+        if (method === 'POST' && formSubmitMatch) {
+            return this.json({
+                id: `sub-${++this.idCounter}`,
+                formId: formSubmitMatch[1],
+                data: body?.data ?? {},
+                submittedAt: new Date().toISOString(),
+            }, 201);
+        }
+        // List form submissions
+        const formSubsMatch = path.match(/^\/api\/v1\/forms\/([^/]+)\/submissions$/);
+        if (method === 'GET' && formSubsMatch) {
+            return this.json({ data: defaultFixtures.formSubmissions, total: defaultFixtures.formSubmissions.length });
+        }
+        // Update form
+        const formPutMatch = path.match(/^\/api\/v1\/forms\/([^/]+)$/);
+        if (method === 'PUT' && formPutMatch) {
+            return this.json({ data: { ...defaultFixtures.forms[0], id: formPutMatch[1], ...body, updatedAt: new Date().toISOString() } });
+        }
+        // Delete form
+        const formDelMatch = path.match(/^\/api\/v1\/forms\/([^/]+)$/);
+        if (method === 'DELETE' && formDelMatch) {
+            return this.json({ success: true });
+        }
+        // ── Scenarios ──────────────────────────────────────────────────────
+        // List scenarios
+        if (method === 'GET' && path === '/api/v1/scenarios') {
+            return this.json({ data: defaultFixtures.scenarios });
+        }
+        // Create scenario
+        if (method === 'POST' && path === '/api/v1/scenarios') {
+            const now = new Date().toISOString();
+            return this.json({ data: {
+                    id: `scen-${++this.idCounter}`,
+                    name: body?.name ?? 'New Scenario',
+                    description: body?.description,
+                    status: 'draft',
+                    baseVersion: 1,
+                    results: {},
+                    createdAt: now,
+                    updatedAt: now,
+                } }, 201);
+        }
+        // Get scenario by ID
+        const scenGetMatch = path.match(/^\/api\/v1\/scenarios\/([^/]+)$/);
+        if (method === 'GET' && scenGetMatch) {
+            return this.json({ data: defaultFixtures.scenarios[0] });
+        }
+        // Scenario mutations
+        const scenMutMatch = path.match(/^\/api\/v1\/scenarios\/([^/]+)\/mutations$/);
+        if (method === 'POST' && scenMutMatch) {
+            return this.json(null, 204);
+        }
+        // Scenario view
+        const scenViewMatch = path.match(/^\/api\/v1\/scenarios\/([^/]+)\/view/);
+        if (method === 'GET' && scenViewMatch) {
+            return this.json({ data: { instances: [], mutations: [], affectedCount: 0 } });
+        }
+        // Scenario impact
+        const scenImpactMatch = path.match(/^\/api\/v1\/scenarios\/([^/]+)\/impact$/);
+        if (method === 'POST' && scenImpactMatch) {
+            return this.json({ data: { affectedInstances: 3, affectedEdges: 1, riskLevel: 'low' } });
+        }
+        // Scenario apply
+        const scenApplyMatch = path.match(/^\/api\/v1\/scenarios\/([^/]+)\/apply$/);
+        if (method === 'POST' && scenApplyMatch) {
+            return this.json({ data: { ...defaultFixtures.scenarios[0], status: 'applied', appliedAt: new Date().toISOString() } });
+        }
+        // Scenario discard
+        const scenDiscardMatch = path.match(/^\/api\/v1\/scenarios\/([^/]+)\/discard$/);
+        if (method === 'POST' && scenDiscardMatch) {
+            return this.json({ data: { ...defaultFixtures.scenarios[0], status: 'discarded' } });
+        }
+        // ── Decision Compare ───────────────────────────────────────────────
+        // Estimate
+        if (method === 'POST' && path === '/api/v1/decision-compares/estimate') {
+            return this.json(defaultFixtures.decisionCompareEstimate);
+        }
+        // Submit
+        if (method === 'POST' && path === '/api/v1/decision-compares') {
+            return this.json(defaultFixtures.decisionCompareSubmit, 202);
+        }
+        // Report
+        const dcReportMatch = path.match(/^\/api\/v1\/decision-compares\/([^/]+)\/report$/);
+        if (method === 'GET' && dcReportMatch) {
+            return this.json(defaultFixtures.decisionCompareReport);
+        }
+        // Evidence
+        const dcEvidenceMatch = path.match(/^\/api\/v1\/decision-compares\/([^/]+)\/evidence$/);
+        if (method === 'GET' && dcEvidenceMatch) {
+            return this.json(defaultFixtures.decisionCompareEvidence);
+        }
+        // Override
+        const dcOverrideMatch = path.match(/^\/api\/v1\/decision-compares\/([^/]+)\/override$/);
+        if (method === 'POST' && dcOverrideMatch) {
+            return this.json({
+                runId: dcOverrideMatch[1],
+                overrideAccepted: true,
+                previousDecision: 'option-a',
+                clientDecision: body?.clientDecision ?? 'option-b',
+                recordedAt: new Date().toISOString(),
+            });
+        }
+        // Poll status (must come after /report, /evidence, /override)
+        const dcPollMatch = path.match(/^\/api\/v1\/decision-compares\/([^/]+)$/);
+        if (method === 'GET' && dcPollMatch) {
+            return this.json({
+                runId: dcPollMatch[1],
+                status: 'succeeded',
+                progress: 100,
+                createdAt: '2026-04-15T10:00:00Z',
+                updatedAt: '2026-04-15T10:05:00Z',
+            });
+        }
+        // Cancel
+        const dcCancelMatch = path.match(/^\/api\/v1\/decision-compares\/([^/]+)$/);
+        if (method === 'DELETE' && dcCancelMatch) {
+            return this.json({
+                runId: dcCancelMatch[1],
+                status: 'cancelled',
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        // ─── Phase 5 of epic #1077 — V1 REST instance CRUD handlers ───────────
+        // Closes #1076. After Phase 4 the SDK uses these REST routes (not /api/
+        // commands/execute) so the mock-server now handles writes natively.
+        // POST /api/v1/object-types/:apiName/instances — create instance
+        const instanceCreateMatch = path.match(/^\/api\/v1\/object-types\/([^/]+)\/instances$/);
+        if (method === 'POST' && instanceCreateMatch && body) {
+            const [, objectType] = instanceCreateMatch;
+            const data = (body.data ?? {});
+            const externalId = (body.externalId ?? body.external_id);
+            const instanceId = `mock-inst-${++this.idCounter}`;
+            const now = new Date().toISOString();
+            const instance = {
+                id: instanceId,
+                object_type_id: objectType,
+                data,
+                title_display: (data.name ?? data.title ?? null),
+                version: 1,
+                status: 'active',
+                source_type: 'manual',
+                external_id: externalId ?? null,
+                created_at: now,
+                updated_at: now,
+                created_by: 'mock-user',
+            };
+            const stored = {
+                $primaryKey: instanceId,
+                $objectType: objectType,
+                $version: 1,
+                ...data,
+            };
+            if (!this.objects.has(objectType))
+                this.objects.set(objectType, []);
+            this.objects.get(objectType).push(stored);
+            return this.json({ success: true, data: instance }, 201);
+        }
+        // POST /api/v1/object-types/:apiName/instances/batch — batch ops
+        const instanceBatchMatch = path.match(/^\/api\/v1\/object-types\/([^/]+)\/instances\/batch$/);
+        if (method === 'POST' && instanceBatchMatch && body) {
+            const [, objectType] = instanceBatchMatch;
+            const operations = Array.isArray(body.updates) ? body.updates : [];
+            let succeeded = 0;
+            const results = [];
+            for (const op of operations) {
+                if (op.type === 'create' && op.data) {
+                    const id = `mock-inst-${++this.idCounter}`;
+                    if (!this.objects.has(objectType))
+                        this.objects.set(objectType, []);
+                    this.objects.get(objectType).push({
+                        $primaryKey: id, $objectType: objectType, $version: 1, ...op.data,
+                    });
+                    results.push({ success: true, id });
+                    succeeded++;
+                }
+                else if (op.type === 'update' && op.id && op.data) {
+                    const list = this.objects.get(objectType) ?? [];
+                    const idx = list.findIndex(o => o.$primaryKey === op.id);
+                    if (idx >= 0) {
+                        list[idx] = { ...list[idx], ...op.data, $version: list[idx].$version + 1 };
+                        results.push({ success: true, id: op.id });
+                        succeeded++;
+                    }
+                    else {
+                        results.push({ success: false, id: op.id, error: 'NOT_FOUND' });
+                    }
+                }
+                else if (op.type === 'delete' && op.id) {
+                    const list = this.objects.get(objectType) ?? [];
+                    const idx = list.findIndex(o => o.$primaryKey === op.id);
+                    if (idx >= 0) {
+                        list.splice(idx, 1);
+                        results.push({ success: true, id: op.id });
+                        succeeded++;
+                    }
+                    else {
+                        results.push({ success: false, id: op.id, error: 'NOT_FOUND' });
+                    }
+                }
+                else {
+                    // Unknown op shape (e.g. type='create' missing data, unknown type) — keep
+                    // results aligned with operations[] so callers can index by position.
+                    results.push({ success: false, id: op.id ?? null, error: 'UNKNOWN_OP' });
+                }
+            }
+            return this.json({
+                success: true,
+                data: { succeeded, failed: operations.length - succeeded, results },
+            });
+        }
+        // PUT/DELETE /api/v1/instances/:id — single regex shared by both verbs
+        const instanceSingleMatch = path.match(/^\/api\/v1\/instances\/([^/]+)$/);
+        // PUT /api/v1/instances/:id — update instance (6C: OCC validation)
+        if (method === 'PUT' && instanceSingleMatch && body) {
+            const instanceUpdateMatch = instanceSingleMatch;
+            const [, instanceId] = instanceUpdateMatch;
+            const data = (body.data ?? {});
+            // Find across all object types (cross-type instance lookup)
+            for (const [objectType, list] of this.objects) {
+                const idx = list.findIndex(o => o.$primaryKey === instanceId);
+                if (idx >= 0) {
+                    // 6C: Validate expectedVersion if provided (OCC)
+                    if (body.expectedVersion !== undefined && body.expectedVersion !== list[idx].$version) {
+                        return this.json({
+                            success: false,
+                            error: {
+                                code: 'VERSION_CONFLICT',
+                                message: `Expected version ${body.expectedVersion} but current is ${list[idx].$version}`,
+                                statusCode: 409,
+                            },
+                        }, 409);
+                    }
+                    const updated = {
+                        ...list[idx],
+                        ...data,
+                        $version: list[idx].$version + 1,
+                    };
+                    list[idx] = updated;
+                    const now = new Date().toISOString();
+                    return this.json({
+                        success: true,
+                        data: {
+                            id: instanceId,
+                            object_type_id: objectType,
+                            data: { ...updated },
+                            version: updated.$version,
+                            status: 'active',
+                            source_type: 'manual',
+                            external_id: null,
+                            created_at: list[idx].$createdAt ?? now,
+                            updated_at: now,
+                            created_by: null,
+                            title_display: null,
+                        },
+                    });
+                }
+            }
+            return this.json({ success: false, error: { code: 'INSTANCE_NOT_FOUND', message: `Instance '${instanceId}' not found` } }, 404);
+        }
+        // DELETE /api/v1/instances/:id — delete (soft) instance (reuses instanceSingleMatch)
+        if (method === 'DELETE' && instanceSingleMatch) {
+            const [, instanceId] = instanceSingleMatch;
+            for (const [, list] of this.objects) {
+                const idx = list.findIndex(o => o.$primaryKey === instanceId);
+                if (idx >= 0) {
+                    list.splice(idx, 1);
+                    return this.json({ success: true, data: { id: instanceId, status: 'deleted' } });
+                }
+            }
+            return this.json({ success: false, error: { code: 'INSTANCE_NOT_FOUND', message: `Instance '${instanceId}' not found` } }, 404);
+        }
+        // ─── Action V1 handlers (ActionBuilder dry-run + invoke) ───────────────
+        // POST /api/v1/actions/:key/dry-run — return PlanArtifactV1 stub
+        const actionDryRunMatch = path.match(/^\/api\/v1\/actions\/([^/]+)\/dry-run$/);
+        if (method === 'POST' && actionDryRunMatch) {
+            const [, actionKey] = actionDryRunMatch;
+            const planId = `mock-plan-${++this.idCounter}`;
+            const now = Date.now();
+            const expiresAt = new Date(now + 5 * 60_000).toISOString();
+            // PlanArtifactV1 stub — matches the canonical shape in
+            // `sdk/packages/client/src/plan-operations.ts:8-87`. All required
+            // fields are present with correct types (strings for versions, nested
+            // objects for workspace/operation/actor/risk/dependencies). Backend
+            // route `actions.routes.ts:444-450` spreads `canApply` into the
+            // artifact, so we mirror that behavior at the top level.
+            return this.json({
+                success: true,
+                data: {
+                    artifactVersion: '1',
+                    planId,
+                    planHash: `mock-hash-${planId}`,
+                    signature: {
+                        algorithm: 'mock',
+                        keyId: 'mock-key',
+                        signed: 'mock-signed',
+                        value: 'mock-signature-value',
+                        trustLevel: 'local_mock',
+                    },
+                    body: {
+                        planSchemaVersion: '1',
+                        planId,
+                        createdAt: new Date(now).toISOString(),
+                        expiresAt,
+                        ttlSeconds: 300,
+                        workspace: { workspaceId: 'mock-ws' },
+                        operation: { kind: 'action', actionKey },
+                        actor: {
+                            initiator: {
+                                principalType: 'user',
+                                principalId: 'mock-user',
+                                displayName: 'Mock User',
+                            },
+                            credential: 'mock-credential',
+                            applyBinding: 'mock-binding',
+                        },
+                        versions: {},
+                        authorization: { requiredScopes: [], grantedScopes: [] },
+                        inputs: (body ?? {}),
+                        dependencies: { targetVersions: {}, readVersions: {}, expectedAbsent: [] },
+                        effects: [],
+                        policyChecks: [],
+                        risk: { level: 'low', requiresConfirmation: false, reasonCodes: [] },
+                        applyConstraints: {},
+                    },
+                    state: { status: 'ready' },
+                    redaction: { mode: 'none', redactedPaths: [] },
+                    meta: {},
+                    // Backend route adds `canApply` at the top level (not part of
+                    // PlanArtifactV1 type but spread into the artifact response).
+                    canApply: true,
+                },
+            });
+        }
+        // POST /api/v1/actions/:key/invoke — return ActionResult stub
+        const actionInvokeMatch = path.match(/^\/api\/v1\/actions\/([^/]+)\/invoke$/);
+        if (method === 'POST' && actionInvokeMatch) {
+            const [, actionKey] = actionInvokeMatch;
+            const runId = `mock-run-${++this.idCounter}`;
+            return this.json({
+                success: true,
+                data: {
+                    // ActionResult minimal shape (matches sdk/packages/client/src/action-builder.ts)
+                    runId,
+                    actionKey,
+                    editedRefs: [],
+                    summary: `Mock execution of action '${actionKey}'`,
+                    blockedSideEffects: [],
+                },
+            });
+        }
+        // ─── Legacy CQRS write paths — return actionable 501 (mitigation) ──────
+        // Pre-Phase-4 the SDK used /api/commands/execute. After Phase 4 (PR #1099)
+        // the SDK uses the REST routes above. The 501 mitigation is kept as a
+        // defensive guard for any legacy code that still hits the old paths.
+        //
+        // Method gate: scoped to write verbs so a future GET /api/commands/history
+        // (read of command_log) wouldn't be 501'd here.
+        const isWriteMethod = method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE';
+        const isLegacyCqrsWrite = isWriteMethod && path.startsWith('/api/commands/');
+        if (isLegacyCqrsWrite) {
+            return this.json({
+                success: false,
+                error: {
+                    code: 'MOCK_LEGACY_CQRS_DEPRECATED',
+                    message: `Mock-server: ${method} ${path} is the legacy CQRS write path. ` +
+                        `Phase 4 of epic #1077 migrated the SDK to REST routes ` +
+                        `(POST /api/v1/object-types/:apiName/instances, PUT/DELETE /api/v1/instances/:id). ` +
+                        `Use the new SDK if you're seeing this.`,
+                    epic: 'https://github.com/growthsystemes/dataforge/issues/1077',
+                },
+            }, 501);
+        }
+        return this.json({ message: `Not implemented: ${method} ${path}` }, 501);
+    }
+    json(data, status = 200) {
+        return new Response(JSON.stringify(data), {
+            status,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    // ── V1 envelope + graph helpers ────────────────────────────────────
+    // Mirror `backend/src/routes/v1/_envelope.ts` shape so SDKs targeting
+    // mock vs real backend see identical fields.
+    v1Envelope(data, diagnostics) {
+        return {
+            data: {
+                ...data,
+                diagnostics: {
+                    workspaceId: 'ws_mock',
+                    ...diagnostics,
+                },
+            },
+            meta: {
+                requestId: `mock_req_${this.idCounter++}`,
+                workspaceId: 'ws_mock',
+                costUnits: 1,
+                estimatedCostUnits: 1,
+                quotaRemaining: null,
+                warnings: [],
+            },
+        };
+    }
+    findObjectByKey(key) {
+        for (const [, objs] of this.objects) {
+            for (const obj of objs) {
+                if (obj.$primaryKey === key)
+                    return obj;
+            }
+        }
+        return null;
+    }
+    vertexFromObject(obj) {
+        return {
+            id: obj.$primaryKey,
+            name: typeof obj.name === 'string' ? obj.name : obj.$primaryKey,
+            type: obj.$objectType,
+            properties: { ...obj },
+        };
+    }
+    /** Bounded BFS — traversal of in-memory edges from `startNodeId`. */
+    traverseGraph(startNodeId, maxDepth, direction) {
+        const visited = new Set();
+        const vertices = [];
+        const edges = [];
+        const queue = [{ key: startNodeId, depth: 0 }];
+        let maxReached = 0;
+        let truncated = false;
+        const HARD_CAP = 200;
+        while (queue.length > 0) {
+            const { key, depth } = queue.shift();
+            if (visited.has(key))
+                continue;
+            visited.add(key);
+            const obj = this.findObjectByKey(key);
+            if (obj)
+                vertices.push(this.vertexFromObject(obj));
+            maxReached = Math.max(maxReached, depth);
+            if (depth >= maxDepth)
+                continue;
+            if (vertices.length >= HARD_CAP) {
+                truncated = true;
+                break;
+            }
+            for (const e of this.edges) {
+                const outbound = e.sourceKey === key;
+                const inbound = e.targetKey === key;
+                if (direction === 'outbound' && !outbound)
+                    continue;
+                if (direction === 'inbound' && !inbound)
+                    continue;
+                if (!outbound && !inbound)
+                    continue;
+                const next = outbound ? e.targetKey : e.sourceKey;
+                if (visited.has(next))
+                    continue;
+                edges.push({ from: e.sourceKey, to: e.targetKey, type: e.linkType });
+                queue.push({ key: next, depth: depth + 1 });
+            }
+        }
+        return {
+            vertices,
+            edges,
+            paths: [],
+            vertexCount: vertices.length,
+            edgeCount: edges.length,
+            pathCount: 0,
+            totalDepth: maxReached,
+            truncated,
+        };
+    }
+    /** Direct neighbours (depth=1) shaped to `GraphNeighborsResult`. */
+    neighborsOf(nodeId) {
+        const centerObj = this.findObjectByKey(nodeId);
+        const center = centerObj ? this.vertexFromObject(centerObj) : null;
+        const vertices = [];
+        const edges = [];
+        const neighbors = [];
+        for (const e of this.edges) {
+            const outbound = e.sourceKey === nodeId;
+            const inbound = e.targetKey === nodeId;
+            if (!outbound && !inbound)
+                continue;
+            const otherKey = outbound ? e.targetKey : e.sourceKey;
+            const obj = this.findObjectByKey(otherKey);
+            if (!obj)
+                continue;
+            const vertex = this.vertexFromObject(obj);
+            vertices.push(vertex);
+            edges.push({ from: e.sourceKey, to: e.targetKey, type: e.linkType });
+            neighbors.push({
+                id: vertex.id,
+                name: vertex.name,
+                type: vertex.type,
+                edgeId: `${e.sourceKey}->${e.targetKey}:${e.linkType}`,
+                edgeType: e.linkType,
+                direction: outbound ? 'outbound' : 'inbound',
+            });
+        }
+        return { center, vertices, edges, neighbors };
+    }
+    /** BFS shortest path (undirected for mock) shaped to `ShortestPathResult`. */
+    shortestPathBetween(sourceId, targetId, maxHops) {
+        if (sourceId === targetId) {
+            const obj = this.findObjectByKey(sourceId);
+            const v = obj ? this.vertexFromObject(obj) : null;
+            return {
+                vertices: v ? [v] : [],
+                edges: [],
+                paths: v ? [{ vertices: [v], edges: [] }] : [],
+                pathCount: v ? 1 : 0,
+                found: !!v,
+                distance: 0,
+                path: v ? [{ id: v.id, name: v.name, type: v.type }] : [],
+            };
+        }
+        const prev = new Map();
+        const visited = new Set([sourceId]);
+        const queue = [{ key: sourceId, depth: 0 }];
+        let found = false;
+        while (queue.length > 0) {
+            const { key, depth } = queue.shift();
+            if (depth >= maxHops)
+                continue;
+            for (const e of this.edges) {
+                const outbound = e.sourceKey === key;
+                const inbound = e.targetKey === key;
+                if (!outbound && !inbound)
+                    continue;
+                const next = outbound ? e.targetKey : e.sourceKey;
+                if (visited.has(next))
+                    continue;
+                visited.add(next);
+                prev.set(next, key);
+                if (next === targetId) {
+                    found = true;
+                    queue.length = 0;
+                    break;
+                }
+                queue.push({ key: next, depth: depth + 1 });
+            }
+        }
+        if (!found) {
+            return { vertices: [], edges: [], paths: [], pathCount: 0, found: false, distance: 0, path: [] };
+        }
+        const keyChain = [targetId];
+        let cur = targetId;
+        while (cur && cur !== sourceId) {
+            cur = prev.get(cur);
+            if (cur)
+                keyChain.unshift(cur);
+        }
+        const path = [];
+        const vertices = [];
+        for (const key of keyChain) {
+            const obj = this.findObjectByKey(key);
+            if (obj) {
+                const v = this.vertexFromObject(obj);
+                vertices.push(v);
+                path.push({ id: v.id, name: v.name, type: v.type });
+            }
+        }
+        const edges = [];
+        for (let i = 0; i < keyChain.length - 1; i++) {
+            const from = keyChain[i];
+            const to = keyChain[i + 1];
+            const edge = this.edges.find((e) => (e.sourceKey === from && e.targetKey === to) || (e.sourceKey === to && e.targetKey === from));
+            if (edge)
+                edges.push({ from: edge.sourceKey, to: edge.targetKey, type: edge.linkType });
+        }
+        return {
+            vertices,
+            edges,
+            paths: [{ vertices, edges }],
+            pathCount: 1,
+            found: true,
+            distance: keyChain.length - 1,
+            path,
+        };
+    }
+    /** Reset all fixtures to default state. */
+    reset(fixtures) {
+        // Bug 33 fix: Deep-clone on reset too
+        this.objects = MockServer.cloneObjectMap(fixtures?.objects ?? defaultFixtures.objects);
+        this.edges = MockServer.cloneEdges(fixtures?.edges ?? defaultFixtures.edges);
+    }
+}
+export function createMockServer(options) {
+    return new MockServer(options);
+}
+//# sourceMappingURL=server.js.map