@shrkcrft/inspector 0.1.0-alpha.2

package/dist/agent-contract-gate.js

@@ -0,0 +1,412 @@
+/**
+ * Agent contract gates.
+ *
+ * The base agent contract is advisory. This module adds an opt-in
+ * gate system that turns a contract into pass/fail signals — and,
+ * optionally, a hard gate for `shrk apply --contract`.
+ *
+ * Read-only. No source writes from this module. Approval writing is a
+ * CLI-only explicit action handled by the command layer.
+ */
+import { createHash, createHmac } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { TaskRiskLevel } from "./task-risk.js";
+import { simulatePlan } from "./plan-simulation.js";
+import { matchContractFileRule, rulesFromLegacyStrings, } from "./contract-file-rule.js";
+export const AGENT_CONTRACT_APPROVAL_SCHEMA = 'sharkcraft.agent-contract-approval/v1';
+export const AGENT_CONTRACT_GATE_SCHEMA = 'sharkcraft.agent-contract-gate/v1';
+export var ContractGateStatus;
+(function (ContractGateStatus) {
+    ContractGateStatus["Pass"] = "pass";
+    ContractGateStatus["RequiresApproval"] = "requires-approval";
+    ContractGateStatus["Fail"] = "fail";
+    ContractGateStatus["Warn"] = "warn";
+})(ContractGateStatus || (ContractGateStatus = {}));
+export var ContractApprovalExpiryStatus;
+(function (ContractApprovalExpiryStatus) {
+    ContractApprovalExpiryStatus["Valid"] = "valid";
+    ContractApprovalExpiryStatus["ExpiresSoon"] = "expires-soon";
+    ContractApprovalExpiryStatus["Expired"] = "expired";
+    ContractApprovalExpiryStatus["NoExpiry"] = "no-expiry";
+    ContractApprovalExpiryStatus["Absent"] = "absent";
+})(ContractApprovalExpiryStatus || (ContractApprovalExpiryStatus = {}));
+const APPROVAL_SECRET_ENV_DEFAULT = 'SHARKCRAFT_CONTRACT_SECRET';
+function canonicalContractJson(contract) {
+    // Deterministic JSON for hashing — exclude `generatedAt` so hashes stay
+    // stable across re-builds of the same task.
+    const { generatedAt: _drop, ...rest } = contract;
+    void _drop;
+    return JSON.stringify(rest, Object.keys(rest).sort());
+}
+export function computeContractHash(contract) {
+    const h = createHash('sha256');
+    h.update(canonicalContractJson(contract));
+    return h.digest('hex');
+}
+function canonicalApprovalJson(a) {
+    const { signature: _drop, ...rest } = a;
+    void _drop;
+    return JSON.stringify(rest, Object.keys(rest).sort());
+}
+export function signApproval(a, secret) {
+    const hmac = createHmac('sha256', secret);
+    hmac.update(canonicalApprovalJson(a));
+    return {
+        ...a,
+        signature: { algo: 'sha256', hmac: hmac.digest('hex'), signedAt: new Date().toISOString() },
+    };
+}
+export function verifyApproval(a, secret) {
+    if (!a.signature)
+        return { ok: false, message: 'No signature.' };
+    const hmac = createHmac('sha256', secret);
+    hmac.update(canonicalApprovalJson(a));
+    const expected = hmac.digest('hex');
+    if (expected !== a.signature.hmac)
+        return { ok: false, message: 'Signature mismatch.' };
+    return { ok: true, message: 'verified' };
+}
+export function buildApproval(input) {
+    const approval = {
+        schema: AGENT_CONTRACT_APPROVAL_SCHEMA,
+        contractHash: input.contractHash,
+        approvedBy: input.approvedBy,
+        reason: input.reason,
+        approvedAt: new Date().toISOString(),
+        approvedGates: input.approvedGates ? [...input.approvedGates] : [],
+    };
+    if (input.contractId !== undefined)
+        approval.contractId = input.contractId;
+    if (input.expiresAt !== undefined)
+        approval.expiresAt = input.expiresAt;
+    const secret = process.env[input.secretEnv ?? APPROVAL_SECRET_ENV_DEFAULT];
+    if (secret)
+        return signApproval(approval, secret);
+    return approval;
+}
+function readJson(file) {
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+function isExpired(a) {
+    if (!a.expiresAt)
+        return false;
+    const t = Date.parse(a.expiresAt);
+    if (Number.isNaN(t))
+        return false;
+    return t < Date.now();
+}
+const EXPIRES_SOON_WINDOW_MS = 4 * 60 * 60 * 1000; // 4 hours
+/**
+ * Parse a relative expiry string like `1h`, `2d`, `30m`, `45s`, `1w` and return
+ * an absolute ISO timestamp from `from` (default now). Returns null when the
+ * input cannot be parsed.
+ */
+export function parseRelativeExpiry(input, from = new Date()) {
+    const m = /^([0-9]+)\s*(s|m|h|d|w)$/i.exec(input.trim());
+    if (!m)
+        return null;
+    const n = Number.parseInt(m[1], 10);
+    const unit = m[2].toLowerCase();
+    const ms = unit === 's' ? n * 1000 :
+        unit === 'm' ? n * 60 * 1000 :
+            unit === 'h' ? n * 60 * 60 * 1000 :
+                unit === 'd' ? n * 24 * 60 * 60 * 1000 :
+                    unit === 'w' ? n * 7 * 24 * 60 * 60 * 1000 : 0;
+    if (ms <= 0)
+        return null;
+    return new Date(from.getTime() + ms).toISOString();
+}
+function classifyExpiry(contract, approval) {
+    if (!approval)
+        return { status: ContractApprovalExpiryStatus.Absent };
+    if (!approval.expiresAt) {
+        const risk = contract.taskRisk.riskLevel;
+        const out = { status: ContractApprovalExpiryStatus.NoExpiry };
+        if (risk === TaskRiskLevel.High || risk === TaskRiskLevel.Critical) {
+            out.noExpiryWarning =
+                `Approval has no --expires-in / --expires-at and task risk is ${risk}; long-lived approvals should be avoided.`;
+        }
+        return out;
+    }
+    const t = Date.parse(approval.expiresAt);
+    if (Number.isNaN(t)) {
+        return { status: ContractApprovalExpiryStatus.NoExpiry, expiresAt: approval.expiresAt };
+    }
+    const remaining = t - Date.now();
+    if (remaining < 0) {
+        return {
+            status: ContractApprovalExpiryStatus.Expired,
+            expiresInMs: remaining,
+            expiresAt: approval.expiresAt,
+            expiredAt: approval.expiresAt,
+        };
+    }
+    if (remaining < EXPIRES_SOON_WINDOW_MS) {
+        return {
+            status: ContractApprovalExpiryStatus.ExpiresSoon,
+            expiresInMs: remaining,
+            expiresAt: approval.expiresAt,
+        };
+    }
+    return {
+        status: ContractApprovalExpiryStatus.Valid,
+        expiresInMs: remaining,
+        expiresAt: approval.expiresAt,
+    };
+}
+function classifyApproval(contract, a, secret) {
+    if (!a)
+        return { status: 'absent' };
+    const hash = computeContractHash(contract);
+    if (a.contractHash !== hash) {
+        return {
+            status: 'mismatched',
+            message: `Approval is for a different contract (expected hash ${hash.slice(0, 12)}…, got ${a.contractHash.slice(0, 12)}…).`,
+        };
+    }
+    if (isExpired(a))
+        return { status: 'expired', message: `Approval expired at ${a.expiresAt}.` };
+    if (a.signature) {
+        if (!secret)
+            return { status: 'present', message: 'Signature present but no secret configured to verify.' };
+        const v = verifyApproval(a, secret);
+        return v.ok
+            ? { status: 'verified', message: v.message }
+            : { status: 'invalid', message: v.message };
+    }
+    return { status: 'unsigned' };
+}
+function gate(id, description, status, detail) {
+    return detail === undefined ? { id, description, status } : { id, description, status, detail };
+}
+export async function checkAgentContract(inspection, contract, options = {}) {
+    const notes = [];
+    let planSimulation;
+    // Resolve approval if provided.
+    let approval;
+    if (options.approvalPath) {
+        if (!existsSync(options.approvalPath)) {
+            notes.push(`Approval file not found: ${options.approvalPath}`);
+        }
+        else {
+            try {
+                approval = readJson(options.approvalPath);
+            }
+            catch (e) {
+                notes.push(`Failed to parse approval: ${e.message}`);
+            }
+        }
+    }
+    const secret = process.env[options.secretEnv ?? APPROVAL_SECRET_ENV_DEFAULT];
+    const approvalClassification = classifyApproval(contract, approval, secret);
+    const approvalAccepted = approval !== undefined &&
+        (approvalClassification.status === 'unsigned' ||
+            approvalClassification.status === 'verified' ||
+            approvalClassification.status === 'present');
+    // Run plan simulation if a plan path was supplied.
+    if (options.planPath) {
+        try {
+            planSimulation = await simulatePlan(inspection, options.planPath, {
+                includeBoundaries: true,
+                includeImpact: true,
+                includeOwnership: true,
+            });
+        }
+        catch (e) {
+            notes.push(`Plan simulation failed: ${e.message}`);
+        }
+    }
+    else if (contract.requiredPlanReviews.length > 0) {
+        notes.push('Contract requires plan review(s) but no --plan was supplied; gate `required-plan-review` cannot validate.');
+    }
+    const gates = [];
+    // Gate 1: human approval gates listed in the contract.
+    if (contract.humanApprovalGates.length === 0) {
+        gates.push(gate('human-approval', 'Human approval gate(s).', ContractGateStatus.Pass, 'No human approval required by this contract.'));
+    }
+    else if (approvalAccepted) {
+        gates.push(gate('human-approval', 'Human approval gate(s).', ContractGateStatus.Pass, `Approved by ${approval.approvedBy}.`));
+    }
+    else {
+        gates.push(gate('human-approval', 'Human approval gate(s).', ContractGateStatus.RequiresApproval, contract.humanApprovalGates.join(' / ')));
+    }
+    // Gate 2: required plan reviews — must have plan supplied + simulation ready.
+    if (contract.requiredPlanReviews.length > 0) {
+        if (!planSimulation) {
+            gates.push(gate('required-plan-review', 'Required plan review.', ContractGateStatus.Fail, 'No --plan supplied or plan simulation failed.'));
+        }
+        else if (planSimulation.applyReadiness === 'blocked-conflicts' ||
+            planSimulation.applyReadiness === 'blocked-boundary' ||
+            planSimulation.applyReadiness === 'blocked-policy' ||
+            planSimulation.applyReadiness === 'blocked-signature' ||
+            planSimulation.applyReadiness === 'blocked-missing-review') {
+            gates.push(gate('required-plan-review', 'Required plan review.', ContractGateStatus.Fail, `Plan simulation: ${planSimulation.applyReadiness}.`));
+        }
+        else {
+            gates.push(gate('required-plan-review', 'Required plan review.', planSimulation.applyReadiness === 'ready-with-review'
+                ? ContractGateStatus.Warn
+                : ContractGateStatus.Pass, `Plan simulation: ${planSimulation.applyReadiness}.`));
+        }
+    }
+    else {
+        gates.push(gate('required-plan-review', 'Required plan review.', ContractGateStatus.Pass, 'Not required.'));
+    }
+    // Gate 3: forbidden files not touched.
+    // Prefer detailed rules. Fall back to legacy string[] (contains-match).
+    const detailedRules = contract.forbiddenFilesDetailed && contract.forbiddenFilesDetailed.length > 0
+        ? contract.forbiddenFilesDetailed
+        : rulesFromLegacyStrings(contract.forbiddenFiles.map((s) => s.split(' ')[0].replace(/\*\*$/, '').replace(/\*$/, '')).filter((s) => s.length > 0));
+    if (detailedRules.length > 0 && planSimulation) {
+        const matches = [];
+        for (const f of planSimulation.files) {
+            for (const r of detailedRules) {
+                if (matchContractFileRule(r, f.relativePath))
+                    matches.push({ file: f.relativePath, rule: r });
+            }
+        }
+        if (matches.length > 0) {
+            const summary = matches
+                .slice(0, 8)
+                .map((m) => `${m.file} (rule: ${m.rule.kind}=${m.rule.pattern})`)
+                .join(', ');
+            gates.push(gate('forbidden-files', 'Forbidden files not touched.', ContractGateStatus.Fail, `Plan touches: ${summary}${matches.length > 8 ? ` (+${matches.length - 8} more)` : ''}.`));
+        }
+        else {
+            gates.push(gate('forbidden-files', 'Forbidden files not touched.', ContractGateStatus.Pass));
+        }
+    }
+    else if (detailedRules.length > 0) {
+        gates.push(gate('forbidden-files', 'Forbidden files not touched.', ContractGateStatus.Warn, 'No --plan supplied; cannot verify forbidden-file gate.'));
+    }
+    else {
+        gates.push(gate('forbidden-files', 'Forbidden files not touched.', ContractGateStatus.Pass, 'None forbidden.'));
+    }
+    // Gate 4: required validations are listed (informational — runtime is the human's job).
+    gates.push(gate('required-validations', 'Required validations listed.', contract.requiredValidations.length > 0 ? ContractGateStatus.Pass : ContractGateStatus.Warn, contract.requiredValidations.length > 0
+        ? `${contract.requiredValidations.length} validation(s) listed.`
+        : 'No validations listed.'));
+    // Gate 5: public-API review required.
+    const publicApi = contract.publicApiRisks.length > 0 || (planSimulation?.publicApiTouched ?? false);
+    if (publicApi) {
+        const reviewsHasApi = contract.requiredReviews.some((r) => r.toLowerCase().includes('api'));
+        if (reviewsHasApi) {
+            gates.push(gate('public-api-review', 'Public-API review required when API touched.', ContractGateStatus.Pass));
+        }
+        else if (approvalAccepted) {
+            gates.push(gate('public-api-review', 'Public-API review required.', ContractGateStatus.Pass, `Approved by ${approval.approvedBy}.`));
+        }
+        else {
+            gates.push(gate('public-api-review', 'Public-API review required.', ContractGateStatus.RequiresApproval, 'Contract does not list an explicit API review.'));
+        }
+    }
+    else {
+        gates.push(gate('public-api-review', 'Public-API review required when API touched.', ContractGateStatus.Pass, 'No public API touched.'));
+    }
+    // Gate 6: risk requires approval.
+    const highRisk = contract.taskRisk.riskLevel === TaskRiskLevel.High || contract.taskRisk.riskLevel === TaskRiskLevel.Critical;
+    if (highRisk || contract.taskRisk.humanApprovalRequired) {
+        if (approvalAccepted) {
+            gates.push(gate('risk-approval', 'High-risk approval.', ContractGateStatus.Pass, `Approved by ${approval.approvedBy}.`));
+        }
+        else {
+            gates.push(gate('risk-approval', 'High-risk approval.', ContractGateStatus.RequiresApproval, `Risk: ${contract.taskRisk.riskLevel} (score ${contract.taskRisk.score}).`));
+        }
+    }
+    else {
+        gates.push(gate('risk-approval', 'High-risk approval.', ContractGateStatus.Pass, 'Not high-risk.'));
+    }
+    // Gate 7: memory adjustment elevates required approval if non-trivial.
+    if (contract.taskRisk.memory && contract.taskRisk.memory.score >= 4) {
+        if (approvalAccepted) {
+            gates.push(gate('memory-elevated-approval', 'Memory-elevated approval.', ContractGateStatus.Pass, `Approved by ${approval.approvedBy}.`));
+        }
+        else {
+            gates.push(gate('memory-elevated-approval', 'Memory-elevated approval.', ContractGateStatus.RequiresApproval, `Memory adjustment +${contract.taskRisk.memory.score} suggests review.`));
+        }
+    }
+    else if (contract.taskRisk.memory && contract.taskRisk.memory.missing) {
+        gates.push(gate('memory-elevated-approval', 'Memory-elevated approval.', ContractGateStatus.Warn, 'Memory index missing.'));
+    }
+    else {
+        gates.push(gate('memory-elevated-approval', 'Memory-elevated approval.', ContractGateStatus.Pass));
+    }
+    const blockingGates = gates.filter((g) => g.status === ContractGateStatus.Fail || g.status === ContractGateStatus.RequiresApproval).map((g) => g.id);
+    const warnGates = gates.filter((g) => g.status === ContractGateStatus.Warn).map((g) => g.id);
+    const pass = blockingGates.length === 0;
+    // Surface approval expiry detail + warn when a high/critical-risk
+    // approval has no expiry.
+    const approvalExpiry = classifyExpiry(contract, approval);
+    if (approvalExpiry.noExpiryWarning)
+        notes.push(approvalExpiry.noExpiryWarning);
+    if (approvalExpiry.status === ContractApprovalExpiryStatus.ExpiresSoon) {
+        notes.push(`Approval expires in ${Math.round((approvalExpiry.expiresInMs ?? 0) / 60000)} min — re-approve before then.`);
+    }
+    const result = {
+        schema: AGENT_CONTRACT_GATE_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        contractHash: computeContractHash(contract),
+        task: contract.task,
+        role: contract.role,
+        mode: contract.mode,
+        gates,
+        approvalStatus: approvalClassification.status,
+        approvalExpiry,
+        pass,
+        blockingGates,
+        warnGates,
+        notes,
+    };
+    if (approval)
+        result.approval = approval;
+    if (approvalClassification.message)
+        result.approvalMessage = approvalClassification.message;
+    if (planSimulation)
+        result.planSimulation = planSimulation;
+    return result;
+}
+export function renderContractCheckText(r) {
+    let out = `=== Contract check ===\n`;
+    out += `  task             ${r.task || '(empty)'}\n`;
+    out += `  role/mode        ${r.role} / ${r.mode}\n`;
+    out += `  contract hash    ${r.contractHash.slice(0, 12)}…\n`;
+    out += `  approval         ${r.approvalStatus}${r.approvalMessage ? ' — ' + r.approvalMessage : ''}\n`;
+    out += `  overall          ${r.pass ? 'PASS' : 'BLOCK'}\n\n`;
+    out += `Gates:\n`;
+    for (const g of r.gates) {
+        out += `  [${g.status.toUpperCase().padEnd(18)}] ${g.id.padEnd(28)} ${g.description}${g.detail ? '  — ' + g.detail : ''}\n`;
+    }
+    if (r.blockingGates.length > 0) {
+        out += `\nBlocking: ${r.blockingGates.join(', ')}\n`;
+    }
+    if (r.warnGates.length > 0)
+        out += `Warnings: ${r.warnGates.join(', ')}\n`;
+    if (r.notes.length > 0) {
+        out += `\nNotes:\n`;
+        for (const n of r.notes)
+            out += `  • ${n}\n`;
+    }
+    return out;
+}
+export function renderContractCheckMarkdown(r) {
+    let out = `# Contract check\n\n`;
+    out += `- **task**: ${r.task || '(empty)'}\n`;
+    out += `- **role / mode**: ${r.role} / ${r.mode}\n`;
+    out += `- **contract hash**: \`${r.contractHash.slice(0, 16)}…\`\n`;
+    out += `- **approval**: ${r.approvalStatus}${r.approvalMessage ? ' — ' + r.approvalMessage : ''}\n`;
+    out += `- **overall**: ${r.pass ? '✅ PASS' : '❌ BLOCK'}\n\n`;
+    out += `## Gates\n\n`;
+    out += `| Status | Gate | Description | Detail |\n| --- | --- | --- | --- |\n`;
+    for (const g of r.gates) {
+        out += `| ${g.status} | \`${g.id}\` | ${g.description} | ${g.detail ?? ''} |\n`;
+    }
+    if (r.blockingGates.length > 0)
+        out += `\n**Blocking**: ${r.blockingGates.join(', ')}\n`;
+    if (r.warnGates.length > 0)
+        out += `**Warnings**: ${r.warnGates.join(', ')}\n`;
+    if (r.notes.length > 0) {
+        out += `\n## Notes\n`;
+        for (const n of r.notes)
+            out += `- ${n}\n`;
+    }
+    return out;
+}

package/dist/agent-contract-templates.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Reusable agent-contract templates.
+ *
+ * `buildAgentContract` derives a contract from inspection + intent. Templates
+ * are reusable starting points that capture *intent classes* — "release task",
+ * "public-API change", "polyglot service change", etc. They are deterministic
+ * dictionaries; rendering merges them with the live contract output.
+ */
+import { type IContractFileRule } from './contract-file-rule.js';
+import { RoleId } from './role-views.js';
+import { AgentContractMode } from './agent-contract.js';
+export declare const AGENT_CONTRACT_TEMPLATE_SCHEMA = "sharkcraft.agent-contract-template/v1";
+export declare enum AgentContractTemplateMatch {
+    Exact = "exact",
+    Partial = "partial",
+    None = "none"
+}
+export interface IAgentContractTemplateAppliesWhen {
+    /** Lowercase substrings that should appear in the task. Any-of. */
+    taskKeywords?: readonly string[];
+    /** Intent kinds that should match (e.g. `release`, `migration`). */
+    intentKinds?: readonly string[];
+    /** Roles this template is intended for. */
+    roles?: readonly RoleId[];
+}
+export interface IAgentContractTemplate {
+    schema: typeof AGENT_CONTRACT_TEMPLATE_SCHEMA;
+    id: string;
+    title: string;
+    description: string;
+    role: RoleId;
+    mode: AgentContractMode;
+    defaultForbiddenFilesDetailed: readonly IContractFileRule[];
+    defaultRequiredValidations: readonly string[];
+    defaultHumanApprovalGates: readonly string[];
+    defaultDefinitionOfDone: readonly string[];
+    defaultRollbackPlan: readonly string[];
+    appliesWhen: IAgentContractTemplateAppliesWhen;
+}
+export declare const AI_AGENT_SAFE_CHANGE_TEMPLATE: IAgentContractTemplate;
+export declare const PUBLIC_API_CHANGE_TEMPLATE: IAgentContractTemplate;
+export declare const RELEASE_TASK_TEMPLATE: IAgentContractTemplate;
+export declare const MIGRATION_TASK_TEMPLATE: IAgentContractTemplate;
+export declare const SECURITY_SENSITIVE_CHANGE_TEMPLATE: IAgentContractTemplate;
+export declare const POLYGLOT_SERVICE_CHANGE_TEMPLATE: IAgentContractTemplate;
+/**
+ * Project-specific contract templates
+ * now live in packs and are merged via `loadAllContractTemplates`. The
+ * engine ships only generic templates here.
+ */
+export declare const ALL_CONTRACT_TEMPLATES: readonly IAgentContractTemplate[];
+export declare function listContractTemplates(): readonly IAgentContractTemplate[];
+export declare function getContractTemplate(id: string): IAgentContractTemplate | null;
+export interface IContractTemplateMatchResult {
+    template: IAgentContractTemplate;
+    match: AgentContractTemplateMatch;
+    reason: string;
+}
+/** Score each template against a task + optional role. Highest score wins. */
+export declare function recommendContractTemplate(task: string, role?: RoleId, intentKind?: string): readonly IContractTemplateMatchResult[];
+export declare function renderContractTemplateMarkdown(t: IAgentContractTemplate, task?: string): string;
+export declare function renderContractTemplateText(t: IAgentContractTemplate, task?: string): string;
+//# sourceMappingURL=agent-contract-templates.d.ts.map

package/dist/agent-contract-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-contract-templates.d.ts","sourceRoot":"","sources":["../src/agent-contract-templates.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,eAAO,MAAM,8BAA8B,0CAA0C,CAAC;AAEtF,oBAAY,0BAA0B;IACpC,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,IAAI,SAAS;CACd;AAED,MAAM,WAAW,iCAAiC;IAChD,mEAAmE;IACnE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,oEAAoE;IACpE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,2CAA2C;IAC3C,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,OAAO,8BAA8B,CAAC;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,iBAAiB,CAAC;IACxB,6BAA6B,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC5D,0BAA0B,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,yBAAyB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,uBAAuB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,WAAW,EAAE,iCAAiC,CAAC;CAChD;AAcD,eAAO,MAAM,6BAA6B,EAAE,sBA0B1C,CAAC;AAEH,eAAO,MAAM,0BAA0B,EAAE,sBA2BvC,CAAC;AAEH,eAAO,MAAM,qBAAqB,EAAE,sBAkClC,CAAC;AAEH,eAAO,MAAM,uBAAuB,EAAE,sBA2BpC,CAAC;AAEH,eAAO,MAAM,kCAAkC,EAAE,sBAmC/C,CAAC;AAEH,eAAO,MAAM,gCAAgC,EAAE,sBAkC7C,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,sBAAsB,EAOnE,CAAC;AAEF,wBAAgB,qBAAqB,IAAI,SAAS,sBAAsB,EAAE,CAEzE;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAE7E;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,sBAAsB,CAAC;IACjC,KAAK,EAAE,0BAA0B,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,8EAA8E;AAC9E,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,GAClB,SAAS,4BAA4B,EAAE,CA4BzC;AAED,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,sBAAsB,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAiC/F;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,sBAAsB,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAiC3F"}