@selvakumaresra/specship 0.1.0

package/dist/server/routes/spec.js

@@ -0,0 +1,105 @@
+/**
+ * Spec layer routes — list / fetch / link assert / link verify / drift queue.
+ *
+ * Every route is project-scoped via `?project=<slug>` (falls back to the
+ * boot-time primary). Returns 409 / `no_project` when neither is selectable.
+ */
+async function resolveCg(app, req, reply) {
+    const cg = await app.activeCg(req);
+    if (!cg) {
+        reply.code(409).send({ error: 'no project selected', code: 'no_project' });
+        return null;
+    }
+    return cg;
+}
+export async function registerSpecRoutes(app) {
+    app.get('/api/specs', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const docs = cg.getSpecQueries().getAllSpecs();
+        return { specs: docs };
+    });
+    app.get('/api/spec/:id', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const sq = cg.getSpecQueries();
+        const spec = sq.getSpecById(req.params.id);
+        if (!spec)
+            return reply.code(404).send({ error: 'spec not found' });
+        const parent = spec.parentId ? sq.getSpecById(spec.parentId) : null;
+        const children = sq.getSpecsByParent(spec.id);
+        const siblings = parent ? sq.getSpecsByParent(parent.id).filter((s) => s.id !== spec.id) : [];
+        const links = sq.getLinksBySpec(spec.id);
+        return { spec, parent, siblings, children, links };
+    });
+    app.get('/api/drift', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const sq = cg.getSpecQueries();
+        const validStates = [
+            'drafted', 'implementing', 'implemented', 'verified',
+            'drifted', 'broken', 'orphaned',
+        ];
+        const requested = (req.query.state ?? 'drifted,broken,orphaned')
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => validStates.includes(s));
+        const limit = Math.min(parseInt(req.query.limit ?? '100', 10) || 100, 500);
+        const links = sq.getLinksByState(requested).slice(0, limit);
+        const out = links.map((l) => {
+            const spec = sq.getSpecById(l.specId);
+            return { ...l, specTitle: spec?.title ?? null };
+        });
+        return { links: out };
+    });
+    app.post('/api/spec/link-assert', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const body = req.body;
+        if (!body?.spec_id || !body.target_file_path || !body.target_qualified_name) {
+            return reply.code(400).send({ error: 'spec_id, target_file_path, target_qualified_name required' });
+        }
+        const sq = cg.getSpecQueries();
+        const spec = sq.getSpecById(body.spec_id);
+        if (!spec)
+            return reply.code(404).send({ error: 'spec not found' });
+        const now = Date.now();
+        const id = sq.upsertSpecLink({
+            specId: body.spec_id,
+            targetFilePath: body.target_file_path,
+            targetQualifiedName: body.target_qualified_name,
+            targetNodeKind: body.target_node_kind ?? 'function',
+            resolvedNodeId: undefined,
+            kind: body.kind ?? 'implements',
+            state: 'implemented',
+            driftAxis: null,
+            specHashAtLink: spec.contentHash,
+            nodeSigAtLink: undefined,
+            provenance: 'agent-asserted',
+            confidence: 1.0,
+            createdAt: now,
+            updatedAt: now,
+        });
+        cg.getSpecLinkResolver().resolveLinksForFiles([body.target_file_path]);
+        return { id, ok: true };
+    });
+    app.post('/api/spec/link-verify', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const body = req.body;
+        if (typeof body?.link_id !== 'number' || (body.result !== 'pass' && body.result !== 'fail')) {
+            return reply.code(400).send({ error: 'link_id (number) and result ("pass"|"fail") required' });
+        }
+        const sq = cg.getSpecQueries();
+        const link = sq.getLinkById(body.link_id);
+        if (!link)
+            return reply.code(404).send({ error: 'link not found' });
+        sq.updateSpecLinkState(body.link_id, body.result === 'pass' ? 'verified' : 'broken', null);
+        return { ok: true, state: body.result === 'pass' ? 'verified' : 'broken' };
+    });
+}

package/dist/server/routes/status.js

@@ -0,0 +1,35 @@
+/**
+ * GET /api/status — backend, journal mode, node/edge counts, drift count,
+ * last index time. Drives the UI's persistent status strip.
+ *
+ * Project-scoped: accepts `?project=<slug>` and serves the matching
+ * SpecShip instance from the registry. When no project is selectable
+ * (no `?project=`, no primary), returns a 409 with `code: 'no_project'`
+ * so the UI can show the picker without blowing up.
+ */
+export async function registerStatusRoutes(app) {
+    app.get('/api/status', async (req, reply) => {
+        const cg = await app.activeCg(req);
+        if (!cg) {
+            return reply.code(409).send({ error: 'no project selected', code: 'no_project' });
+        }
+        const stats = cg.getStats();
+        const lastIndexed = cg.getLastIndexedAt();
+        const drift = cg
+            .getSpecQueries()
+            .getLinksByState(['drifted', 'broken', 'orphaned']).length;
+        return {
+            projectPath: cg.getProjectRoot ? cg.getProjectRoot() : '',
+            backend: cg.getBackend(),
+            journalMode: cg.getJournalMode(),
+            nodeCount: stats.nodeCount,
+            edgeCount: stats.edgeCount,
+            fileCount: stats.fileCount,
+            drift,
+            lastIndexed: lastIndexed != null ? new Date(lastIndexed).toISOString() : null,
+            nodesByKind: stats.nodesByKind,
+            filesByLanguage: stats.filesByLanguage,
+            dbSizeBytes: stats.dbSizeBytes,
+        };
+    });
+}

package/dist/server/routes/workflow.js

@@ -0,0 +1,184 @@
+/**
+ * Workflow routes — discover / run / resume / cancel / approve / reject /
+ * runs list / run detail + SSE event stream.
+ *
+ * All project-scoped via `?project=<slug>` (falls back to primary). Each
+ * handler resolves the active SpecShip instance from the registry and
+ * constructs the WorktreeProvider + WorkflowExecutor on demand against
+ * that instance's queries. Construction is cheap (both classes just stash
+ * references), and pinning a single executor across all projects would
+ * tie the entire surface to whichever instance loaded first.
+ *
+ * The SSE endpoint streams workflow_events as they're appended to the DB
+ * (polling 500ms). For v1 polling the same SQLite the executor writes to is
+ * faster + more reliable than wiring an in-process event bus across packages.
+ */
+async function resolveCg(app, req, reply) {
+    const cg = await app.activeCg(req);
+    if (!cg) {
+        reply.code(409).send({ error: 'no project selected', code: 'no_project' });
+        return null;
+    }
+    return cg;
+}
+export async function registerWorkflowRoutes(app) {
+    // Lazy import — keeps the server bootable even if the workflow engine
+    // is disabled in the current build profile.
+    const { discoverWorkflows, loadWorkflowByName } = await import('@selvakumaresra/specship/dist/workflows/discovery.js');
+    const { WorkflowExecutor } = await import('@selvakumaresra/specship/dist/workflows/executor.js');
+    const { WorktreeProvider } = await import('@selvakumaresra/specship/dist/isolation/worktree.js');
+    const executorCache = new WeakMap();
+    /** Build (or fetch cached) executor + worktree provider for a project. */
+    function executorFor(cg) {
+        const sq = cg.getSpecQueries();
+        const cached = executorCache.get(sq);
+        if (cached)
+            return { sq, executor: cached.executor, projectRoot: cached.projectRoot };
+        const projectRoot = cg.getProjectRoot ? cg.getProjectRoot() : process.cwd();
+        const worktrees = new WorktreeProvider(sq);
+        const executor = new WorkflowExecutor(sq, worktrees);
+        executorCache.set(sq, { executor, projectRoot });
+        return { sq, executor, projectRoot };
+    }
+    app.get('/api/workflows', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { projectRoot } = executorFor(cg);
+        return discoverWorkflows(projectRoot);
+    });
+    app.post('/api/workflows/runs', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { executor, projectRoot } = executorFor(cg);
+        const body = req.body;
+        if (!body?.workflowName)
+            return reply.code(400).send({ error: 'workflowName required' });
+        const loaded = loadWorkflowByName(projectRoot, body.workflowName);
+        if (!loaded)
+            return reply.code(404).send({ error: 'workflow not found' });
+        const startPromise = executor.start(loaded.workflow, {
+            projectRoot,
+            inputs: body.inputs,
+            variables: body.variables,
+        });
+        const result = await Promise.race([
+            startPromise,
+            new Promise((resolve) => setTimeout(() => resolve({ run: { id: 'pending', status: 'starting' } }), 50)),
+        ]);
+        startPromise.catch(() => { });
+        return { runId: result.run.id, status: result.run.status };
+    });
+    app.get('/api/workflows/runs', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { sq } = executorFor(cg);
+        const limit = Math.min(parseInt(req.query.limit ?? '50', 10) || 50, 500);
+        return { runs: sq.getAllWorkflowRuns(limit) };
+    });
+    app.get('/api/workflows/runs/:id', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { sq } = executorFor(cg);
+        const run = sq.getWorkflowRunById(req.params.id);
+        if (!run)
+            return reply.code(404).send({ error: 'run not found' });
+        const events = sq.getEventsByRun(req.params.id, 500);
+        return { run, events };
+    });
+    /**
+     * SSE event stream. Polls the events table every 500ms for any events
+     * newer than the last id sent. Closes when the run hits a terminal state.
+     */
+    app.get('/api/workflows/runs/:id/events', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { sq } = executorFor(cg);
+        const runId = req.params.id;
+        let lastId = parseInt(req.query.since ?? '0', 10) || 0;
+        reply.raw.setHeader('Content-Type', 'text/event-stream');
+        reply.raw.setHeader('Cache-Control', 'no-cache');
+        reply.raw.setHeader('Connection', 'keep-alive');
+        reply.raw.flushHeaders();
+        let closed = false;
+        req.raw.on('close', () => { closed = true; });
+        const tick = async () => {
+            if (closed)
+                return;
+            const events = sq.getEventsByRun(runId, 1000);
+            const fresh = events.filter((e) => e.id > lastId);
+            for (const e of fresh) {
+                reply.raw.write(`id: ${e.id}\n`);
+                reply.raw.write(`event: ${e.eventType}\n`);
+                reply.raw.write(`data: ${JSON.stringify(e)}\n\n`);
+                lastId = e.id;
+            }
+            const run = sq.getWorkflowRunById(runId);
+            if (!run || ['completed', 'failed', 'cancelled'].includes(run.status)) {
+                reply.raw.write(`event: done\ndata: ${JSON.stringify({ status: run?.status })}\n\n`);
+                reply.raw.end();
+                return;
+            }
+            setTimeout(() => { void tick(); }, 500);
+        };
+        void tick();
+    });
+    app.post('/api/workflows/runs/:id/approve', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { executor } = executorFor(cg);
+        try {
+            executor.approve(req.params.id, req.body?.comment);
+            return { ok: true };
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    app.post('/api/workflows/runs/:id/reject', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { executor } = executorFor(cg);
+        try {
+            executor.reject(req.params.id, req.body?.reason);
+            return { ok: true };
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    app.post('/api/workflows/runs/:id/cancel', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { executor } = executorFor(cg);
+        try {
+            executor.cancel(req.params.id, req.body?.reason);
+            return { ok: true };
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    app.post('/api/workflows/runs/:id/resume', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const { sq, executor, projectRoot } = executorFor(cg);
+        const run = sq.getWorkflowRunById(req.params.id);
+        if (!run)
+            return reply.code(404).send({ error: 'run not found' });
+        const loaded = loadWorkflowByName(projectRoot, run.workflowName);
+        if (!loaded)
+            return reply.code(404).send({ error: 'workflow definition missing' });
+        const promise = executor.resume(loaded.workflow, req.params.id, { projectRoot });
+        promise.catch(() => { });
+        return { ok: true };
+    });
+}

package/dist/server/server.js

@@ -0,0 +1,202 @@
+/**
+ * Fastify HTTP server for specship + SpecShip Desktop UI.
+ *
+ * Routes follow the design spec — `/api/graph/*`, `/api/spec/*`,
+ * `/api/drift`, `/api/workflows/*`, `/api/claude/*`. Each route group lives
+ * in its own file under `./routes/` and registers itself on a passed
+ * Fastify instance.
+ *
+ * Why Fastify: lighter than Express, faster, first-class TypeScript types,
+ * built-in JSON schema validation, plugins for CORS + SSE. The 30K LoC
+ * Archon UI port pulls ~20+ API routes — Fastify's plugin model keeps the
+ * registration code tidy.
+ */
+import path from 'node:path';
+import { existsSync, promises as fs } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import fastifyStatic from '@fastify/static';
+import { startWatcher } from './ingest/index.js';
+import { ProjectRegistry } from './project-registry.js';
+import { registerGraphRoutes } from './routes/graph.js';
+import { registerSpecRoutes } from './routes/spec.js';
+import { registerWorkflowRoutes } from './routes/workflow.js';
+import { registerClaudeRoutes } from './routes/claude.js';
+import { registerStatusRoutes } from './routes/status.js';
+import { registerMemoryRoutes } from './routes/memory.js';
+import { registerProjectsRoutes } from './routes/projects.js';
+/**
+ * Lazy-import the specship core. Two delivery shapes are supported:
+ *
+ *   1. **Bundled** — the platform-specific npm tarball lays the compiled
+ *      server out at `<bundle>/lib/dist/server/server.js` and the specship
+ *      core at `<bundle>/lib/dist/index.js`. We try this relative path
+ *      first so the bundled mode never depends on Node's package
+ *      resolution finding `@selvakumaresra/specship` (it won't, the
+ *      bundle stages a single package by name `@selvakumaresra/specship`).
+ *
+ *   2. **Workspace / dev** — `packages/server/dist/server.js` imports via
+ *      the workspace `file:../..` dep. Falls through to the named import.
+ *
+ * The function caches the resolved module so the lookup only runs once.
+ */
+let cachedSpecShip = null;
+async function loadSpecShip() {
+    if (cachedSpecShip)
+        return cachedSpecShip;
+    // Bundled mode: dist/server/server.js → ../index.js (root dist/index.js).
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const candidate = path.resolve(here, '..', 'index.js');
+        if (existsSync(candidate)) {
+            cachedSpecShip = (await import(pathToFileURL(candidate).href));
+            return cachedSpecShip;
+        }
+    }
+    catch { /* fall through */ }
+    // Workspace/dev: resolve via the named dep.
+    cachedSpecShip = await import('@selvakumaresra/specship');
+    return cachedSpecShip;
+}
+export async function createServer(options) {
+    const host = options.host ?? '127.0.0.1';
+    const port = options.port ?? 4242;
+    const verbose = options.verbose ?? false;
+    const app = Fastify({
+        logger: verbose
+            ? { transport: { target: 'pino-pretty', options: { translateTime: 'HH:MM:ss.l' } } }
+            : false,
+    });
+    if (options.cors !== false) {
+        // Permissive CORS for local dev. The server is bound to loopback by
+        // default, so the broad allowlist is fine — Browsers won't get to it
+        // from a non-localhost origin without explicit user override.
+        await app.register(cors, {
+            origin: true,
+            credentials: false,
+        });
+    }
+    // Lazy-load specship. Used as the open() impl for the registry, and
+    // (only when a primary path is set) to open the primary instance below.
+    const cgMod = await loadSpecShip();
+    const registry = new ProjectRegistry({ verbose }, (p) => cgMod.SpecShip.open(p));
+    // Primary project (optional). When set, specship-scoped routes default to
+    // it when no `?project=<slug>` is provided, and the analytics ingest
+    // hooks into its SQLite handle.
+    let primaryCg = null;
+    if (options.projectRoot) {
+        primaryCg = await registry.get(options.projectRoot);
+        if (!primaryCg && verbose) {
+            console.error(`[specship-server] primary project ${options.projectRoot} not initialized — booting projectless`);
+        }
+    }
+    // Start the JSONL ingest watcher in-process unless the caller already
+    // provided one or explicitly opted out. Hooks into the primary project's
+    // SQLite handle — when there's no primary, analytics endpoints will return
+    // 409 until one is set (typically the next server restart with -p).
+    let watcher = options.watcher ?? null;
+    let ownedWatcher = false;
+    if (!watcher && options.ingest !== false && primaryCg) {
+        const cgAny = primaryCg;
+        const dbHandle = cgAny.db?.getDb ? cgAny.db.getDb() : cgAny.queries?.db;
+        if (dbHandle) {
+            watcher = startWatcher(dbHandle, { verbose });
+            ownedWatcher = true;
+            if (verbose)
+                console.error('[specship-server] JSONL ingest watcher started');
+        }
+    }
+    else if (!primaryCg && options.ingest !== false && verbose) {
+        console.error('[specship-server] no primary project — analytics will be empty until one is set');
+    }
+    // Decorate the Fastify instance so route handlers can access shared state
+    // without globals or DI containers.
+    app.decorate('projects', registry);
+    app.decorate('primaryCg', primaryCg);
+    app.decorate('watcher', watcher);
+    // activeCg(req): resolve `?project=<slug>` → SpecShip instance, with the
+    // primary as fallback. Returns null when nothing is selectable; route
+    // handlers respond 409 in that case.
+    app.decorate('activeCg', async function (req) {
+        const q = (req.query ?? {});
+        if (q.project) {
+            const bySlug = await registry.getBySlug(q.project);
+            if (bySlug)
+                return bySlug;
+        }
+        if (q.projectPath) {
+            const byPath = await registry.get(q.projectPath);
+            if (byPath)
+                return byPath;
+        }
+        return primaryCg;
+    });
+    // Register route groups.
+    await registerStatusRoutes(app);
+    await registerGraphRoutes(app);
+    await registerSpecRoutes(app);
+    await registerWorkflowRoutes(app);
+    await registerClaudeRoutes(app);
+    await registerMemoryRoutes(app);
+    await registerProjectsRoutes(app);
+    // Optional: serve the built Angular UI from `webDir` and fall back to
+    // index.html for client-side routes. Must register AFTER the /api/*
+    // routes so they take precedence over the SPA wildcard.
+    if (options.webDir) {
+        const indexPath = path.join(options.webDir, 'index.html');
+        let indexBuffer = null;
+        try {
+            indexBuffer = await fs.readFile(indexPath);
+        }
+        catch {
+            if (verbose) {
+                console.error(`[specship-server] webDir provided but index.html not found at ${indexPath} — skipping static mount`);
+            }
+        }
+        if (indexBuffer) {
+            await app.register(fastifyStatic, {
+                root: options.webDir,
+                prefix: '/',
+                // index.html is served via the SPA fallback so it always reflects
+                // the latest bytes (even when a future hot-swap drops a new build).
+                index: false,
+                wildcard: false,
+            });
+            const cachedIndex = indexBuffer;
+            app.setNotFoundHandler((request, reply) => {
+                // Only fall back for browser GETs that aren't API requests. API
+                // 404s should stay 404s so the UI can surface them properly.
+                if (request.method !== 'GET') {
+                    reply.code(404).send({ error: 'not found' });
+                    return;
+                }
+                if (request.url.startsWith('/api/')) {
+                    reply.code(404).send({ error: 'not found' });
+                    return;
+                }
+                reply.code(200).type('text/html').send(cachedIndex);
+            });
+            if (verbose)
+                console.error(`[specship-server] serving SPA from ${options.webDir}`);
+        }
+    }
+    await app.listen({ host, port });
+    const url = `http://${host}:${port}`;
+    return {
+        app,
+        url,
+        host,
+        port,
+        stop: async () => {
+            if (ownedWatcher && watcher) {
+                try {
+                    watcher.stop();
+                }
+                catch { /* ignore */ }
+            }
+            registry.closeAll();
+            await app.close();
+        },
+    };
+}

package/dist/sync/git-hooks.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Git Sync Hooks
+ *
+ * When the live file watcher is disabled (e.g. on WSL2 `/mnt/*` drives,
+ * see watch-policy.ts), the SpecShip index would otherwise go stale until
+ * the user runs `specship sync` by hand. As an opt-in alternative, we can
+ * install git hooks that refresh the index after the operations that change
+ * files on disk: commit, merge (covers `git pull`), and checkout.
+ *
+ * The hooks run `specship sync` in the background so they never block git,
+ * and are guarded by `command -v specship` so they no-op cleanly when the
+ * CLI isn't on PATH. Our snippet is delimited by marker comments so install
+ * is idempotent and removal preserves any user-authored hook content.
+ */
+export type GitHookName = 'post-commit' | 'post-merge' | 'post-checkout';
+/** Hooks installed by default: commit, merge (git pull), and checkout. */
+export declare const DEFAULT_SYNC_HOOKS: GitHookName[];
+export interface GitHookResult {
+    /** Hook names that were created or updated. */
+    installed: GitHookName[];
+    /** Resolved hooks directory, or null when not a git repo. */
+    hooksDir: string | null;
+    /** Reason nothing happened (e.g. not a git repository). */
+    skipped?: string;
+}
+/**
+ * Whether `projectRoot` is inside a git working tree. Returns false if git
+ * isn't installed or the path isn't a repo.
+ */
+export declare function isGitRepo(projectRoot: string): boolean;
+/**
+ * Install (or update) the SpecShip sync hooks in a git repository.
+ * Idempotent: re-running replaces our marker block rather than duplicating
+ * it, and any user-authored hook content is preserved.
+ */
+export declare function installGitSyncHook(projectRoot: string, hooks?: GitHookName[]): GitHookResult;
+/**
+ * Remove the SpecShip sync hooks. Strips only our marker block; deletes the
+ * hook file entirely when nothing but a shebang remains, otherwise rewrites
+ * the user's content untouched.
+ */
+export declare function removeGitSyncHook(projectRoot: string, hooks?: GitHookName[]): GitHookResult;
+/** Whether any SpecShip sync hook is currently installed. */
+export declare function isSyncHookInstalled(projectRoot: string, hooks?: GitHookName[]): boolean;
+//# sourceMappingURL=git-hooks.d.ts.map

package/dist/sync/git-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-hooks.d.ts","sourceRoot":"","sources":["../../src/sync/git-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AASH,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,YAAY,GAAG,eAAe,CAAC;AAEzE,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,EAAE,WAAW,EAAmD,CAAC;AAEhG,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,SAAS,EAAE,WAAW,EAAE,CAAC;IACzB,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAYtD;AAiED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,WAAW,EAAuB,GACxC,aAAa,CAmCf;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,WAAW,EAAuB,GACxC,aAAa,CA0Bf;AAED,6DAA6D;AAC7D,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,WAAW,EAAuB,GACxC,OAAO,CAOT"}