specrails-desktop 2.0.0

package/server/dist/docs-router.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDocsRouter = createDocsRouter;
+const express_1 = require("express");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+// ─── Docs directory resolution ────────────────────────────────────────────────
+// Try ~/.specrails/docs/ first (user-editable), then fall back to bundled docs/
+function resolveDocsDir() {
+    const userDocsDir = path_1.default.join(os_1.default.homedir(), '.specrails', 'docs');
+    if (fs_1.default.existsSync(userDocsDir)) {
+        return userDocsDir;
+    }
+    // Bundled docs: try relative to this file (works in dev and compiled)
+    const candidates = [
+        path_1.default.resolve(__dirname, '../docs'), // dev: server/ -> ../docs
+        path_1.default.resolve(__dirname, '../../docs'), // compiled: server/dist/ -> ../../docs
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Fall back to user dir (will be empty until populated)
+    return userDocsDir;
+}
+// ─── Category configuration ───────────────────────────────────────────────────
+/**
+ * Top-level `.md` files are surfaced under a synthetic "guides" category.
+ * Any subdirectory becomes its own category, with the directory name as slug
+ * and a friendly label resolved from `CATEGORY_LABELS` (or title-cased).
+ */
+const TOP_LEVEL_CATEGORY_SLUG = 'guides';
+const CATEGORY_LABELS = {
+    guides: 'Guides',
+    platforms: 'Platforms',
+    internals: 'Internals',
+    // Legacy folders (kept so user-customized ~/.specrails/docs trees still work)
+    general: 'General',
+    product: 'Product',
+    engineering: 'Engineering',
+    operations: 'Operations',
+};
+/**
+ * Preferred display order. Categories not in this list come after, in the
+ * order `fs.readdirSync` returns them.
+ */
+const CATEGORY_ORDER = ['guides', 'platforms', 'internals', 'general', 'product', 'engineering', 'operations'];
+/**
+ * Preferred document order within the "guides" category. Files not listed
+ * here are appended in alphabetical order so adding a new doc never breaks
+ * the build.
+ */
+const GUIDES_DOC_ORDER = [
+    'getting-started',
+    'creating-specs',
+    'running-pipelines',
+    'tracking-cost',
+    'customizing',
+    'terminal',
+    'cli',
+    'codex',
+];
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function slugToTitle(slug) {
+    return slug
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function categoryLabel(slug) {
+    return CATEGORY_LABELS[slug] ?? slugToTitle(slug);
+}
+function extractTitle(content, slug) {
+    const match = content.match(/^#\s+(.+)$/m);
+    return match ? match[1].trim() : slugToTitle(slug);
+}
+function sortBy(items, preferredOrder, keyFn) {
+    const preferredIndex = (key) => {
+        const i = preferredOrder.indexOf(key);
+        return i === -1 ? Number.MAX_SAFE_INTEGER : i;
+    };
+    return [...items].sort((a, b) => {
+        const aKey = keyFn(a);
+        const bKey = keyFn(b);
+        const ai = preferredIndex(aKey);
+        const bi = preferredIndex(bKey);
+        if (ai !== bi)
+            return ai - bi;
+        return aKey.localeCompare(bKey);
+    });
+}
+function readMarkdownFiles(dir) {
+    try {
+        return fs_1.default.readdirSync(dir).filter((f) => f.endsWith('.md') && f.toLowerCase() !== 'readme.md');
+    }
+    catch {
+        return [];
+    }
+}
+function readDocEntry(file, filePath) {
+    const slug = file.replace(/\.md$/, '');
+    try {
+        const content = fs_1.default.readFileSync(filePath, 'utf-8');
+        return { title: extractTitle(content, slug), slug };
+    }
+    catch {
+        return { title: slugToTitle(slug), slug };
+    }
+}
+function buildCategories(docsDir) {
+    if (!fs_1.default.existsSync(docsDir))
+        return [];
+    const categories = [];
+    // 1. Top-level .md files → "guides" category
+    const topFiles = readMarkdownFiles(docsDir);
+    if (topFiles.length > 0) {
+        const docs = topFiles.map((f) => readDocEntry(f, path_1.default.join(docsDir, f)));
+        const ordered = sortBy(docs, GUIDES_DOC_ORDER, (d) => d.slug);
+        categories.push({ name: categoryLabel(TOP_LEVEL_CATEGORY_SLUG), slug: TOP_LEVEL_CATEGORY_SLUG, docs: ordered });
+    }
+    // 2. Each subdirectory → its own category
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(docsDir, { withFileTypes: true });
+    }
+    catch {
+        entries = [];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        // Avoid colliding with synthetic top-level slug
+        if (entry.name === TOP_LEVEL_CATEGORY_SLUG)
+            continue;
+        const catDir = path_1.default.join(docsDir, entry.name);
+        const files = readMarkdownFiles(catDir);
+        const docs = files.map((f) => readDocEntry(f, path_1.default.join(catDir, f)));
+        // Sort docs within unknown categories alphabetically.
+        docs.sort((a, b) => a.slug.localeCompare(b.slug));
+        categories.push({ name: categoryLabel(entry.name), slug: entry.name, docs });
+    }
+    return sortBy(categories, CATEGORY_ORDER, (c) => c.slug);
+}
+function isValidCategorySlug(cat) {
+    // basename(cat) === cat guards against slashes, but `path.basename('..') === '..'`,
+    // so '.'/'..' slip through and `path.join(docsDir, '..', ...)` escapes one level
+    // up (B4). Reject the dot segments explicitly.
+    return (cat.length > 0 &&
+        cat !== '.' &&
+        cat !== '..' &&
+        cat === path_1.default.basename(cat) &&
+        !cat.includes('/') &&
+        !cat.includes('\\'));
+}
+// ─── Router ───────────────────────────────────────────────────────────────────
+function createDocsRouter() {
+    const router = (0, express_1.Router)();
+    router.get('/', (_req, res) => {
+        const docsDir = resolveDocsDir();
+        const categories = buildCategories(docsDir);
+        res.json({ categories });
+    });
+    router.get('/:category/:slug', (req, res) => {
+        const { category, slug } = req.params;
+        if (!isValidCategorySlug(category)) {
+            res.status(404).json({ error: 'Category not found' });
+            return;
+        }
+        // Prevent directory traversal in slug too
+        const safeSlug = path_1.default.basename(slug);
+        if (safeSlug !== slug || slug.includes('/') || slug.includes('\\')) {
+            res.status(400).json({ error: 'Invalid slug' });
+            return;
+        }
+        const docsDir = resolveDocsDir();
+        // For the synthetic "guides" category, files live at the top level of docsDir.
+        const filePath = category === TOP_LEVEL_CATEGORY_SLUG
+            ? path_1.default.join(docsDir, `${safeSlug}.md`)
+            : path_1.default.join(docsDir, category, `${safeSlug}.md`);
+        // B4: defence-in-depth — never serve a file resolved outside docsDir, even
+        // if a future change loosens the slug/category validation above.
+        const rel = path_1.default.relative(path_1.default.resolve(docsDir), path_1.default.resolve(filePath));
+        if (rel.startsWith('..') || path_1.default.isAbsolute(rel)) {
+            res.status(404).json({ error: 'Document not found' });
+            return;
+        }
+        if (!fs_1.default.existsSync(filePath)) {
+            res.status(404).json({ error: 'Document not found' });
+            return;
+        }
+        let content;
+        try {
+            content = fs_1.default.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            res.status(500).json({ error: 'Failed to read document' });
+            return;
+        }
+        const title = extractTitle(content, safeSlug);
+        res.json({ title, content, category, slug: safeSlug });
+    });
+    return router;
+}

package/server/dist/explore-contract-refine.js

@@ -0,0 +1,421 @@
+"use strict";
+/**
+ * Explore Spec — Contract Refine
+ *
+ * Post-commit refinement turn that appends a structured "Contract Layer"
+ * section to a committed Explore Spec ticket. The refine spawn is a single
+ * structural Claude turn with a byte-stable system prompt (cache-friendly),
+ * read-only (no tools), that emits one ```contract-layer fenced JSON block.
+ *
+ * This module contains the pure pieces (prompt builder, parser, renderer,
+ * kill switch). The actual spawn lifecycle lives in ChatManager.
+ *
+ * See openspec/changes/explore-spec-contract-refine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACT_LAYER_SEPARATOR = exports.CONTRACT_MARKER_USER_MESSAGE = exports.CONTRACT_PROMPT_VERSION = void 0;
+exports.isExploreContractRefineKillSwitchActive = isExploreContractRefineKillSwitchActive;
+exports.buildContractRefineSystemPrompt = buildContractRefineSystemPrompt;
+exports.parseContractLayerBlock = parseContractLayerBlock;
+exports.stripContractLayerBlock = stripContractLayerBlock;
+exports.renderContractLayerMarkdown = renderContractLayerMarkdown;
+exports.appendContractLayerToDescription = appendContractLayerToDescription;
+exports.hasContractLayer = hasContractLayer;
+exports.splitDescriptionAtContractLayer = splitDescriptionAtContractLayer;
+exports.CONTRACT_PROMPT_VERSION = 1;
+exports.CONTRACT_MARKER_USER_MESSAGE = [
+    'CONTRACT REFINE — structural pass.',
+    '',
+    'The user has already committed the spec. Do NOT continue exploring, do NOT',
+    'ask questions, do NOT call tools. Emit EXACTLY ONE fenced code block tagged',
+    '`contract-layer` containing the JSON shape described in your system prompt.',
+    'No prose before or after the block.',
+].join('\n');
+// ─── Kill switch ─────────────────────────────────────────────────────────────
+/**
+ * Returns `true` when the app-wide kill switch is active and Contract Refine
+ * spawns MUST be skipped regardless of per-project toggles.
+ *
+ * The env var `SPECRAILS_EXPLORE_CONTRACT_REFINE` controls the feature:
+ *   - unset / any other value      → feature ENABLED (kill switch inactive)
+ *   - `0` / `false` / `off` (CI)   → feature DISABLED (kill switch active)
+ */
+function isExploreContractRefineKillSwitchActive(envValue = process.env.SPECRAILS_EXPLORE_CONTRACT_REFINE) {
+    if (envValue == null)
+        return false;
+    const v = envValue.trim().toLowerCase();
+    return v === '0' || v === 'false' || v === 'off';
+}
+// ─── System prompt ───────────────────────────────────────────────────────────
+const EXAMPLE_BLOCK = `\`\`\`contract-layer
+{
+  "contractVersion": 1,
+  "namingContract": {
+    "enums": [
+      { "name": "RoundState", "values": ["INTRO","FIGHTING","KO_FREEZE","ROUND_END","MATCH_END"], "file": "engine/game_loop.py" }
+    ],
+    "fields": [
+      { "name": "p1_rounds_won", "type": "int", "where": "Match" }
+    ],
+    "functions": [
+      { "signature": "Match.advance_round_state(input_state) -> RoundState", "file": "engine/game_loop.py" }
+    ],
+    "files": [
+      { "path": "engine/game_loop.py", "purpose": "extend update() with RoundState machine" }
+    ]
+  },
+  "dataShapes": [
+    { "name": "Match", "ts": "{ p1RoundsWon: number; p2RoundsWon: number; roundTimerFrames: number; state: RoundState }" }
+  ],
+  "stateMachine": "INTRO -> FIGHTING -> (KO_FREEZE | TIMEOUT) -> ROUND_END -> (INTRO | MATCH_END)",
+  "invariants": [
+    "p1_rounds_won + p2_rounds_won + double_kos <= 3",
+    "round_timer_frames only decrements while state == FIGHTING"
+  ],
+  "fileTouchList": [
+    { "path": "engine/game_loop.py", "action": "extend", "reason": "round state machine + transitions" },
+    { "path": "engine/hud.py", "action": "extend", "reason": "round counter + KO banner" }
+  ]
+}
+\`\`\``;
+/**
+ * Build the structural-only system prompt for a Contract Refine turn.
+ *
+ * MUST be byte-stable across two consecutive calls — the only inputs that
+ * vary the output are intentional version bumps (CONTRACT_PROMPT_VERSION).
+ */
+function buildContractRefineSystemPrompt() {
+    return [
+        '# Contract Refine — structural pass',
+        '',
+        'You are running a STRUCTURAL post-commit refinement on a spec that has already',
+        'been committed by the user. Your sole job is to emit a single fenced code block',
+        'tagged `contract-layer` containing a JSON object that anchors the spec with',
+        'prescriptive, anti-reinvention details (exact names, types, file paths,',
+        'invariants). Downstream agents (Architect, Developer, Reviewer) will read these',
+        'anchors to avoid inventing divergent identifiers.',
+        '',
+        '## Hard rules',
+        '',
+        '- DO NOT modify, restate, paraphrase, or critique the user-authored title,',
+        '  description, labels, priority, or acceptance criteria of the committed spec.',
+        '- DO NOT call any tool. Do not Read, Grep, Glob, or Bash anything. Work only',
+        '  from the conversation transcript and the committed spec body already in',
+        '  context.',
+        '- DO NOT ask clarifying questions. If a section has no concrete content,',
+        '  emit an empty array (or `null` for `stateMachine`).',
+        '- Output EXACTLY one fenced code block tagged `contract-layer`. No prose',
+        '  before or after the block. No second block.',
+        '',
+        '## Required JSON shape',
+        '',
+        '```',
+        '{',
+        '  "contractVersion": 1,',
+        '  "namingContract": {',
+        '    "enums":     [{ "name": string, "values": string[], "file": string }],',
+        '    "fields":    [{ "name": string, "type": string, "where": string }],',
+        '    "functions": [{ "signature": string, "file": string }],',
+        '    "files":     [{ "path": string, "purpose": string }]',
+        '  },',
+        '  "dataShapes":    [{ "name": string, "ts": string }],',
+        '  "stateMachine":  string | null,',
+        '  "invariants":    string[],',
+        '  "fileTouchList": [{ "path": string, "action": "create" | "extend" | "delete", "reason": string }]',
+        '}',
+        '```',
+        '',
+        '## Example output',
+        '',
+        EXAMPLE_BLOCK,
+        '',
+        `## Prompt version: ${exports.CONTRACT_PROMPT_VERSION}`,
+        '',
+    ].join('\n');
+}
+// ─── Parser ──────────────────────────────────────────────────────────────────
+const CONTRACT_FENCE_RE = /```contract-layer\s*\n([\s\S]*?)\n```/;
+function asString(v) {
+    return typeof v === 'string' ? v : undefined;
+}
+function asStringArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((s) => typeof s === 'string');
+}
+function normaliseNamingContract(raw) {
+    const r = (raw ?? {});
+    const enums = Array.isArray(r.enums) ? r.enums : [];
+    const fields = Array.isArray(r.fields) ? r.fields : [];
+    const functions = Array.isArray(r.functions) ? r.functions : [];
+    const files = Array.isArray(r.files) ? r.files : [];
+    return {
+        enums: enums
+            .map((e) => {
+            const o = (e ?? {});
+            const name = asString(o.name);
+            const file = asString(o.file);
+            if (!name || !file)
+                return null;
+            return { name, values: asStringArray(o.values), file };
+        })
+            .filter((x) => x !== null),
+        fields: fields
+            .map((e) => {
+            const o = (e ?? {});
+            const name = asString(o.name);
+            const type = asString(o.type);
+            const where = asString(o.where);
+            if (!name || !type || !where)
+                return null;
+            return { name, type, where };
+        })
+            .filter((x) => x !== null),
+        functions: functions
+            .map((e) => {
+            const o = (e ?? {});
+            const signature = asString(o.signature);
+            const file = asString(o.file);
+            if (!signature || !file)
+                return null;
+            return { signature, file };
+        })
+            .filter((x) => x !== null),
+        files: files
+            .map((e) => {
+            const o = (e ?? {});
+            const path = asString(o.path);
+            const purpose = asString(o.purpose);
+            if (!path || !purpose)
+                return null;
+            return { path, purpose };
+        })
+            .filter((x) => x !== null),
+    };
+}
+function normaliseDataShapes(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((e) => {
+        const o = (e ?? {});
+        const name = asString(o.name);
+        const ts = asString(o.ts);
+        if (!name || !ts)
+            return null;
+        return { name, ts };
+    })
+        .filter((x) => x !== null);
+}
+function normaliseFileTouch(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((e) => {
+        const o = (e ?? {});
+        const path = asString(o.path);
+        const action = asString(o.action);
+        const reason = asString(o.reason);
+        if (!path || !reason)
+            return null;
+        if (action !== 'create' && action !== 'extend' && action !== 'delete')
+            return null;
+        return { path, action, reason };
+    })
+        .filter((x) => x !== null);
+}
+/**
+ * Parse a `contract-layer` fenced block from a raw assistant text.
+ *
+ * - Returns `{ ok: false, reason: 'not-found' }` when no block is present.
+ * - Returns `{ ok: false, reason: 'malformed' }` when JSON parse fails.
+ * - Returns `{ ok: false, reason: 'missing-version' }` when `contractVersion`
+ *   is missing or not equal to 1.
+ * - Unknown top-level keys are dropped silently.
+ * - Missing optional arrays default to `[]`.
+ * - `stateMachine` defaults to `null` if missing or non-string.
+ */
+function parseContractLayerBlock(raw) {
+    try {
+        const match = raw.match(CONTRACT_FENCE_RE);
+        if (!match)
+            return { ok: false, reason: 'not-found' };
+        let payload;
+        try {
+            payload = JSON.parse(match[1]);
+        }
+        catch {
+            return { ok: false, reason: 'malformed' };
+        }
+        const obj = (payload ?? {});
+        if (obj.contractVersion !== 1) {
+            return { ok: false, reason: 'missing-version' };
+        }
+        const stateMachineRaw = obj.stateMachine;
+        const value = {
+            contractVersion: 1,
+            namingContract: normaliseNamingContract(obj.namingContract),
+            dataShapes: normaliseDataShapes(obj.dataShapes),
+            stateMachine: typeof stateMachineRaw === 'string' ? stateMachineRaw : null,
+            invariants: asStringArray(obj.invariants),
+            fileTouchList: normaliseFileTouch(obj.fileTouchList),
+        };
+        return { ok: true, value };
+    }
+    catch {
+        return { ok: false, reason: 'parser-error' };
+    }
+}
+/**
+ * Strip the `contract-layer` fenced block from raw text (for chat content
+ * broadcast to the client). Returns the input unchanged when no block is
+ * present.
+ */
+function stripContractLayerBlock(raw) {
+    return raw.replace(CONTRACT_FENCE_RE, '').replace(/\n{3,}/g, '\n\n').trim();
+}
+// ─── Renderer ────────────────────────────────────────────────────────────────
+const NA_LINE = '_N/A — model did not produce items for this subsection._';
+exports.CONTRACT_LAYER_SEPARATOR = '\n\n---\n\n## Contract Layer\n\n';
+function renderNamingContract(nc) {
+    const lines = [];
+    const hasAny = nc.enums.length || nc.fields.length || nc.functions.length || nc.files.length;
+    if (!hasAny)
+        return NA_LINE;
+    if (nc.enums.length) {
+        lines.push('**Enums**');
+        for (const e of nc.enums) {
+            lines.push(`- \`${e.name}\` in \`${e.file}\` — values: ${e.values.map((v) => `\`${v}\``).join(', ') || '_(none)_'}`);
+        }
+        lines.push('');
+    }
+    if (nc.fields.length) {
+        lines.push('**Fields**');
+        for (const f of nc.fields) {
+            lines.push(`- \`${f.name}: ${f.type}\` on \`${f.where}\``);
+        }
+        lines.push('');
+    }
+    if (nc.functions.length) {
+        lines.push('**Functions**');
+        for (const f of nc.functions) {
+            lines.push(`- \`${f.signature}\` — \`${f.file}\``);
+        }
+        lines.push('');
+    }
+    if (nc.files.length) {
+        lines.push('**Files**');
+        for (const f of nc.files) {
+            lines.push(`- \`${f.path}\` — ${f.purpose}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
+function renderDataShapes(shapes) {
+    if (!shapes.length)
+        return NA_LINE;
+    const lines = [];
+    for (const s of shapes) {
+        lines.push(`**${s.name}**`);
+        lines.push('```ts');
+        lines.push(s.ts);
+        lines.push('```');
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
+function renderStateMachine(sm) {
+    if (!sm)
+        return NA_LINE;
+    return ['```', sm, '```'].join('\n');
+}
+function renderInvariants(items) {
+    if (!items.length)
+        return NA_LINE;
+    return items.map((i) => `- ${i}`).join('\n');
+}
+function renderFileTouchList(entries) {
+    if (!entries.length)
+        return NA_LINE;
+    const rows = ['| Path | Action | Reason |', '|------|--------|--------|'];
+    for (const e of entries) {
+        const safeReason = e.reason.replace(/\|/g, '\\|');
+        rows.push(`| \`${e.path}\` | ${e.action} | ${safeReason} |`);
+    }
+    return rows.join('\n');
+}
+/**
+ * Render a parsed Contract Layer to a deterministic markdown subsection.
+ * The output begins after the `## Contract Layer` heading and contains the
+ * five labelled subsections in fixed order.
+ */
+function renderContractLayerMarkdown(layer) {
+    return [
+        '### Naming Contract',
+        '',
+        renderNamingContract(layer.namingContract),
+        '',
+        '### Data Shapes',
+        '',
+        renderDataShapes(layer.dataShapes),
+        '',
+        '### State Machine',
+        '',
+        renderStateMachine(layer.stateMachine),
+        '',
+        '### Invariants',
+        '',
+        renderInvariants(layer.invariants),
+        '',
+        '### File Touch List',
+        '',
+        renderFileTouchList(layer.fileTouchList),
+        '',
+    ].join('\n');
+}
+/**
+ * Append the Contract Layer to a ticket description, producing the canonical
+ * `userBody\n\n---\n\n## Contract Layer\n\n<section>` shape.
+ */
+function appendContractLayerToDescription(userBody, layer) {
+    // B59: a Contract Refine retry must REPLACE an existing Contract Layer, not
+    // append a second one. If the body already carries a layer, strip it down to
+    // the user-authored part first so re-running is idempotent.
+    const base = hasContractLayer(userBody)
+        ? splitDescriptionAtContractLayer(userBody).user
+        : userBody;
+    const trimmed = base.replace(/\s+$/, '');
+    return `${trimmed}${exports.CONTRACT_LAYER_SEPARATOR}${renderContractLayerMarkdown(layer)}`;
+}
+/**
+ * Detects whether a ticket description already contains a Contract Layer.
+ */
+function hasContractLayer(description) {
+    if (!description)
+        return false;
+    return description.includes(exports.CONTRACT_LAYER_SEPARATOR.trim());
+}
+/**
+ * Splits a ticket description into the user-authored body and the contract
+ * layer markdown (when present). When no Contract Layer is detected, returns
+ * `{ user: description, contract: null }`.
+ */
+function splitDescriptionAtContractLayer(description) {
+    const idx = description.indexOf(exports.CONTRACT_LAYER_SEPARATOR);
+    if (idx < 0) {
+        // also check the trimmed variant in case of stray whitespace
+        const altSep = '\n---\n\n## Contract Layer\n';
+        const altIdx = description.indexOf(altSep);
+        if (altIdx < 0)
+            return { user: description, contract: null };
+        return {
+            user: description.slice(0, altIdx),
+            contract: description.slice(altIdx + altSep.length),
+        };
+    }
+    return {
+        user: description.slice(0, idx),
+        contract: description.slice(idx + exports.CONTRACT_LAYER_SEPARATOR.length),
+    };
+}