@oscharko-dev/keiko-contracts 0.2.8 → 0.2.9

package/dist/container-runtime.js

@@ -0,0 +1,287 @@
+// Governed container engine detection + execution wire contract (Issue #1388, Epic #1491,
+// ADR-0070). This leaf module owns the wire-stable vocabulary for the container runtime pilot only.
+// It is intentionally pure: no IO, no process execution, no clock, no randomness. The ONLY in-package
+// imports are the `CommandRule` shape reused for the defense-in-depth allowlist and the two runtime
+// capability vocabularies reused (aliased, never redefined) for the engine state.
+//
+// The runner never accepts free-form argv, image refs, or flags. A request names a `taskId` from a
+// server-frozen catalog; the server resolves that id to a vetted `ContainerTask` whose `image` is in
+// a closed allowlist and whose docker/podman argv is hardened by the server. Detection and execution
+// live in keiko-server (composing keiko-tools `runCommand`), so the browser never gains container,
+// process, shell, or filesystem authority.
+// ─── Schema version ───────────────────────────────────────────────────────────────
+export const CONTAINER_RUNTIME_SCHEMA_VERSION = "1";
+export const CONTAINER_ENGINE_IDS = Object.freeze([
+    "docker",
+    "podman",
+]);
+export const CONTAINER_MOUNT_MODES = Object.freeze([
+    "read-only",
+]);
+export const CONTAINER_NETWORK_MODES = Object.freeze([
+    "none",
+]);
+export const CONTAINER_TASK_KINDS = Object.freeze([
+    "diagnostic",
+    "verify",
+]);
+export const CONTAINER_FAILURE_REASONS = Object.freeze([
+    "none",
+    "non-zero-exit",
+    "engine-unavailable",
+    "image-missing",
+    "pull-denied",
+    "mount-failure",
+    "timed-out",
+    "cancelled",
+    "denied",
+    "spawn-error",
+    "output-capped",
+]);
+export const CONTAINER_RUNNER_EVENT_KINDS = Object.freeze([
+    "run-started",
+    "run-completed",
+    "run-failed",
+    "run-cancelled",
+]);
+// ─── Allowlist (defense-in-depth, D4) ──────────────────────────────────────────────
+// `runCommand` denies the WHOLE invocation if ANY `denyFlags` member appears ANYWHERE in argv (in
+// `--flag x` or `--flag=x` form — see keiko-tools/src/sandbox.ts). The runner passes the server-
+// FROZEN hardened argv to `runCommand`, so `denyFlags` MUST NOT contain any flag the server's own
+// frozen argv emits, or the runner would self-deny its own hardened run. The frozen `docker run`
+// argv emits `--rm`, `--network`, `--read-only`, `--cap-drop`, `--security-opt`, `--pids-limit`,
+// `--memory`, `--cpus`, `--pull`, `-v`; those are therefore EXCLUDED from `denyFlags`. The decisive
+// safety control is the server-frozen argv + closed catalog (D2/D3) — this list is pure defense-in-
+// depth against escalation flags the server NEVER emits, catching a hypothetical future regression
+// where a client-influenced token reaches the argv.
+const CONTAINER_DENY_FLAGS = Object.freeze([
+    "--privileged",
+    "--volume", // long form of -v; the server uses only the short `-v`, so reject any extra mount
+    "--mount",
+    "--device",
+    "--cap-add",
+    "--net", // alias of --network; server uses the canonical --network, reject the alias
+    "--pid",
+    "--ipc",
+    "--user",
+    "-c",
+]);
+export const CONTAINER_TASK_RULES = Object.freeze([
+    {
+        executable: "docker",
+        allowedSubcommands: Object.freeze(["version", "info", "run"]),
+        denyFlags: CONTAINER_DENY_FLAGS,
+    },
+    {
+        executable: "podman",
+        allowedSubcommands: Object.freeze(["version", "info", "run"]),
+        denyFlags: CONTAINER_DENY_FLAGS,
+    },
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOneOf(value, allowed) {
+    return typeof value === "string" && allowed.includes(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isPositiveFinite(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function collectOptionalRequestErrors(input, errors) {
+    if (input.timeoutMs !== undefined && !isPositiveFinite(input.timeoutMs)) {
+        errors.push("timeoutMs must be a positive finite number");
+    }
+    if (input.requestId !== undefined && typeof input.requestId !== "string") {
+        errors.push("requestId must be a string");
+    }
+}
+// Parses an incoming run request at the BFF trust boundary. Collects ALL field errors in a fixed
+// order (deterministic strings for test assertions); never throws.
+export function parseContainerRunRequest(input) {
+    const errors = [];
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["request must be an object"] };
+    }
+    if (!isNonEmptyString(input.projectId)) {
+        errors.push("projectId must be a non-empty string");
+    }
+    if (!isNonEmptyString(input.taskId)) {
+        errors.push("taskId must be a non-empty string");
+    }
+    collectOptionalRequestErrors(input, errors);
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+function validateOptionalStringField(value, key, path, errors) {
+    if (value[key] !== undefined && typeof value[key] !== "string") {
+        errors.push(`${path}.${key} must be a string`);
+    }
+}
+function validateEngineStatus(value, index, errors) {
+    const path = `engines[${String(index)}]`;
+    if (!isRecord(value)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    if (!isOneOf(value.engine, CONTAINER_ENGINE_IDS)) {
+        errors.push(`${path}.engine is invalid`);
+    }
+    if (typeof value.state !== "string" || value.state.length === 0) {
+        errors.push(`${path}.state must be a non-empty string`);
+    }
+    validateOptionalStringField(value, "version", path, errors);
+    validateOptionalStringField(value, "unavailableReason", path, errors);
+    validateOptionalStringField(value, "remediationHint", path, errors);
+}
+function validateCapabilityScalars(value, errors) {
+    if (value.schemaVersion !== CONTAINER_RUNTIME_SCHEMA_VERSION) {
+        errors.push("schemaVersion is invalid");
+    }
+    const generatedAtMs = value.generatedAtMs;
+    if (typeof generatedAtMs !== "number" ||
+        !Number.isSafeInteger(generatedAtMs) ||
+        generatedAtMs < 0) {
+        errors.push("generatedAtMs must be a non-negative safe integer");
+    }
+    const deadlineMs = value.deadlineMs;
+    if (typeof deadlineMs !== "number" || !Number.isSafeInteger(deadlineMs) || deadlineMs < 1) {
+        errors.push("deadlineMs must be a positive safe integer");
+    }
+    if (typeof value.anyAvailable !== "boolean") {
+        errors.push("anyAvailable must be a boolean");
+    }
+}
+function validateEnginesArray(value, errors) {
+    if (!Array.isArray(value.engines)) {
+        errors.push("engines must be an array");
+    }
+    else {
+        value.engines.forEach((entry, index) => {
+            validateEngineStatus(entry, index, errors);
+        });
+    }
+}
+export function validateContainerCapabilityResponse(value) {
+    const errors = [];
+    if (!isRecord(value)) {
+        return { ok: false, errors: ["response must be an object"] };
+    }
+    validateCapabilityScalars(value, errors);
+    validateEnginesArray(value, errors);
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: value };
+}
+function validateContainerTaskArgs(value, path, errors) {
+    const args = value.args;
+    if (!Array.isArray(args)) {
+        errors.push(`${path}.args must be an array`);
+        return;
+    }
+    if (!args.every((arg) => typeof arg === "string")) {
+        errors.push(`${path}.args must be an array of strings`);
+    }
+}
+function validateContainerTask(value, index, errors) {
+    const path = `tasks[${String(index)}]`;
+    if (!isRecord(value)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    if (!isNonEmptyString(value.id))
+        errors.push(`${path}.id must be a non-empty string`);
+    if (!isNonEmptyString(value.label))
+        errors.push(`${path}.label must be a non-empty string`);
+    if (!isNonEmptyString(value.image))
+        errors.push(`${path}.image must be a non-empty string`);
+    if (!isOneOf(value.kind, CONTAINER_TASK_KINDS))
+        errors.push(`${path}.kind is invalid`);
+    if (!isOneOf(value.engine, CONTAINER_ENGINE_IDS))
+        errors.push(`${path}.engine is invalid`);
+    validateContainerTaskArgs(value, path, errors);
+}
+function validateCatalogScalars(value, errors) {
+    if (value.schemaVersion !== CONTAINER_RUNTIME_SCHEMA_VERSION) {
+        errors.push("schemaVersion is invalid");
+    }
+    if (!isNonEmptyString(value.projectId)) {
+        errors.push("projectId must be a non-empty string");
+    }
+    if (typeof value.engineAvailable !== "boolean") {
+        errors.push("engineAvailable must be a boolean");
+    }
+}
+export function validateContainerTaskCatalog(value) {
+    const errors = [];
+    if (!isRecord(value)) {
+        return { ok: false, errors: ["catalog must be an object"] };
+    }
+    validateCatalogScalars(value, errors);
+    if (!Array.isArray(value.tasks)) {
+        errors.push("tasks must be an array");
+    }
+    else {
+        value.tasks.forEach((task, index) => {
+            validateContainerTask(task, index, errors);
+        });
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: value };
+}
+function validateResultScalars(value, errors) {
+    if (value.schemaVersion !== CONTAINER_RUNTIME_SCHEMA_VERSION) {
+        errors.push("schemaVersion is invalid");
+    }
+    if (!isNonEmptyString(value.runId))
+        errors.push("runId must be a non-empty string");
+    if (!isNonEmptyString(value.taskId))
+        errors.push("taskId must be a non-empty string");
+    if (!isOneOf(value.kind, CONTAINER_TASK_KINDS))
+        errors.push("kind is invalid");
+    if (!isOneOf(value.engine, CONTAINER_ENGINE_IDS))
+        errors.push("engine is invalid");
+    if (!isOneOf(value.failureReason, CONTAINER_FAILURE_REASONS)) {
+        errors.push("failureReason is invalid");
+    }
+}
+function validateResultNumbers(value, errors) {
+    const exitCode = value.exitCode;
+    if (exitCode !== null && (typeof exitCode !== "number" || !Number.isInteger(exitCode))) {
+        errors.push("exitCode must be an integer or null");
+    }
+    const durationMs = value.durationMs;
+    if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0) {
+        errors.push("durationMs must be a non-negative finite number");
+    }
+}
+function validateResultFlagsAndText(value, errors) {
+    if (typeof value.truncated !== "boolean")
+        errors.push("truncated must be a boolean");
+    if (typeof value.timedOut !== "boolean")
+        errors.push("timedOut must be a boolean");
+    if (typeof value.stdout !== "string")
+        errors.push("stdout must be a string");
+    if (typeof value.stderr !== "string")
+        errors.push("stderr must be a string");
+}
+export function validateContainerRunResult(value) {
+    const errors = [];
+    if (!isRecord(value)) {
+        return { ok: false, errors: ["result must be an object"] };
+    }
+    validateResultScalars(value, errors);
+    validateResultNumbers(value, errors);
+    validateResultFlagsAndText(value, errors);
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: value };
+}

package/dist/context-engineering.js

@@ -44,8 +44,8 @@ const TOKEN_BYTES_PER_TOKEN_DIVISOR = 3.5;
 // Small fixed structural overhead per segment, modelling per-message framing. Empty input
 // returns exactly this (never 0 / NaN).
 const TOKEN_STRUCTURAL_OVERHEAD = 2;
-// Mirrors conversation-budget.ts utf8ByteLength: TextEncoder when available, char-length
-// fallback for any legacy harness without it. Never throws.
+// Uses TextEncoder when available, with a char-length fallback for any legacy
+// harness without it. Never throws.
 function utf8ByteLength(text) {
     if (typeof TextEncoder !== "undefined") {
         return new TextEncoder().encode(text).length;

package/dist/discussion-intelligence.d.ts

@@ -0,0 +1,70 @@
+import type { VoiceProfile } from "./gateway.js";
+import type { CitationDiscipline, ContradictionPolicy, GroundingDirective } from "./prompt-enhancer.js";
+export declare const DISCUSSION_INTELLIGENCE_SCHEMA_VERSION: "1";
+export declare function isDiscussionIntelligenceSchemaVersionSupported(version: unknown): boolean;
+export type DiscussionMode = "challenge" | "review" | "decide" | "brainstorm" | "evidence-check";
+export declare const DISCUSSION_MODES: readonly DiscussionMode[];
+export declare function isDiscussionMode(value: unknown): value is DiscussionMode;
+export declare function assertNeverDiscussionMode(value: never): never;
+export type ConfidenceLevel = "high" | "medium" | "low";
+export declare const DISCUSSION_CONFIDENCE_LEVELS: readonly ConfidenceLevel[];
+export declare function confidenceLevelFromScore(score: number): ConfidenceLevel;
+export type DisagreementFacet = "evidence" | "assumptions" | "uncertainty";
+export declare const DISAGREEMENT_FACETS: readonly DisagreementFacet[];
+export type DiscussionDirective = "state-position-then-evidence" | "challenge-stated-assumptions" | "surface-counter-evidence" | "list-explicit-assumptions" | "disclose-uncertainty-and-confidence" | "cite-evidence-or-state-none" | "offer-decision-with-tradeoffs" | "expand-option-space-before-converging" | "verify-claims-against-evidence" | "defer-to-user-on-unresolved-contradiction";
+export declare const DISCUSSION_DIRECTIVES: readonly DiscussionDirective[];
+export declare function assertNeverDiscussionDirective(value: never): never;
+export declare const DISCUSSION_DIRECTIVE_TEMPLATES: Readonly<Record<DiscussionDirective, string>>;
+export declare const DISCUSSION_DIRECTIVE_FACETS: Readonly<Record<DiscussionDirective, readonly DisagreementFacet[]>>;
+export interface DiscussionModePlan {
+    readonly mode: DiscussionMode;
+    readonly challengesAssumptions: boolean;
+    readonly requiresExplicitAssumptions: boolean;
+    readonly requiresUncertaintyDisclosure: boolean;
+    readonly citationDiscipline: CitationDiscipline;
+    readonly contradictionPolicy: ContradictionPolicy;
+    readonly groundingDirectives: readonly GroundingDirective[];
+    readonly producesDecisionRecommendation: boolean;
+    readonly mandatedFacets: readonly DisagreementFacet[];
+    readonly directives: readonly DiscussionDirective[];
+}
+export declare const DISCUSSION_MODE_PLANS: Readonly<Record<DiscussionMode, DiscussionModePlan>>;
+export declare function discussionModePlan(mode: DiscussionMode): DiscussionModePlan;
+export declare function discussionDirectivesCoverFacets(plan: DiscussionModePlan): boolean;
+export declare function voiceCanDriveDiscussion(profile: VoiceProfile): boolean;
+export type DiscussionTurnStatus = "active" | "interrupted" | "recovered" | "resolved";
+export declare const DISCUSSION_TURN_STATUSES: readonly DiscussionTurnStatus[];
+export declare const DISCUSSION_TURN_STATUS_TRANSITIONS: Readonly<Record<DiscussionTurnStatus, readonly DiscussionTurnStatus[]>>;
+export declare function isDiscussionTurnStatus(value: unknown): value is DiscussionTurnStatus;
+export declare function canTransitionDiscussionTurnStatus(from: DiscussionTurnStatus, to: DiscussionTurnStatus): boolean;
+export declare function assertNeverDiscussionTurnStatus(value: never): never;
+export declare function discussionTopicIdReasons(value: unknown): readonly string[];
+export declare function isValidDiscussionTopicId(value: unknown): value is string;
+export interface DiscussionTurnContext {
+    readonly schemaVersion: typeof DISCUSSION_INTELLIGENCE_SCHEMA_VERSION;
+    readonly mode: DiscussionMode;
+    readonly topicId: string;
+    readonly turnIndex: number;
+    readonly status: DiscussionTurnStatus;
+}
+export declare function beginDiscussionTurn(mode: DiscussionMode, topicId: string, turnIndex: number): DiscussionTurnContext;
+export declare function applyDiscussionInterruption(ctx: DiscussionTurnContext): DiscussionTurnContext;
+export declare function applyDiscussionRecovery(ctx: DiscussionTurnContext): DiscussionTurnContext;
+export declare function resolveDiscussionTurn(ctx: DiscussionTurnContext): DiscussionTurnContext;
+export interface DiscussionTurnSummary {
+    readonly mode: DiscussionMode;
+    readonly status: DiscussionTurnStatus;
+    readonly turnIndex: number;
+    readonly mandatedFacetCount: number;
+    readonly confidence?: ConfidenceLevel;
+}
+export declare function summarizeDiscussionTurn(ctx: DiscussionTurnContext, confidenceScore?: number): DiscussionTurnSummary;
+export type DiscussionValidationResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reasons: readonly string[];
+};
+export declare function validateDiscussionTurnContext(value: unknown): DiscussionValidationResult;
+export declare function validateDiscussionModePlan(value: unknown): DiscussionValidationResult;
+//# sourceMappingURL=discussion-intelligence.d.ts.map

package/dist/discussion-intelligence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discussion-intelligence.d.ts","sourceRoot":"","sources":["../src/discussion-intelligence.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAI9B,eAAO,MAAM,sCAAsC,EAAG,GAAY,CAAC;AAEnE,wBAAgB,8CAA8C,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAExF;AAMD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,GAAG,gBAAgB,CAAC;AAEjG,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAM5C,CAAC;AAEX,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAExE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAE7D;AAKD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAExD,eAAO,MAAM,4BAA4B,EAAE,SAAS,eAAe,EAIzD,CAAC;AASX,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAWvE;AAKD,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,aAAa,GAAG,aAAa,CAAC;AAE3E,eAAO,MAAM,mBAAmB,EAAE,SAAS,iBAAiB,EAIlD,CAAC;AAKX,MAAM,MAAM,mBAAmB,GAC3B,8BAA8B,GAC9B,8BAA8B,GAC9B,0BAA0B,GAC1B,2BAA2B,GAC3B,qCAAqC,GACrC,6BAA6B,GAC7B,+BAA+B,GAC/B,uCAAuC,GACvC,gCAAgC,GAChC,2CAA2C,CAAC;AAEhD,eAAO,MAAM,qBAAqB,EAAE,SAAS,mBAAmB,EAWtD,CAAC;AAEX,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAElE;AAID,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAoB/E,CAAC;AASX,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAChD,MAAM,CAAC,mBAAmB,EAAE,SAAS,iBAAiB,EAAE,CAAC,CAYjD,CAAC;AAMX,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IACxC,QAAQ,CAAC,2BAA2B,EAAE,OAAO,CAAC;IAC9C,QAAQ,CAAC,6BAA6B,EAAE,OAAO,CAAC;IAChD,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAChD,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;IAClD,QAAQ,CAAC,mBAAmB,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC5D,QAAQ,CAAC,8BAA8B,EAAE,OAAO,CAAC;IACjD,QAAQ,CAAC,cAAc,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACtD,QAAQ,CAAC,UAAU,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACrD;AAKD,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAoG7E,CAAC;AAEX,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,kBAAkB,CAE3E;AAOD,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAQjF;AAOD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAEtE;AAOD,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,aAAa,GAAG,WAAW,GAAG,UAAU,CAAC;AAEvF,eAAO,MAAM,wBAAwB,EAAE,SAAS,oBAAoB,EAK1D,CAAC;AAKX,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,MAAM,CAAC,oBAAoB,EAAE,SAAS,oBAAoB,EAAE,CAAC,CAMrD,CAAC;AAEX,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAIpF;AAED,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,oBAAoB,EAC1B,EAAE,EAAE,oBAAoB,GACvB,OAAO,CAET;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAEnE;AAuBD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE,CAwB1E;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExE;AAKD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,aAAa,EAAE,OAAO,sCAAsC,CAAC;IACtE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC;AAID,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,qBAAqB,CAevB;AAgBD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,qBAAqB,GAAG,qBAAqB,CAE7F;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,qBAAqB,GAAG,qBAAqB,CAEzF;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,GAAG,qBAAqB,CAEvF;AAGD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;CACvC;AAID,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,qBAAqB,EAC1B,eAAe,CAAC,EAAE,MAAM,GACvB,qBAAqB,CAWvB;AAGD,MAAM,MAAM,0BAA0B,GAClC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAAE,GACrB;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAUhE,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,0BAA0B,CAsBxF;AAiCD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,0BAA0B,CAgBrF"}