@nextera.one/axis-server-sdk 2.2.1 → 2.2.3

package/dist/cce-pipeline-DbGBSsCG.d.ts

@@ -0,0 +1,294 @@
+import { A as AxisSensor } from './axis-sensor-GBEI3Fab.js';
+
+declare const CCE_PROTOCOL_VERSION: "cce-v1";
+declare const CCE_DERIVATION: {
+    readonly REQUEST: "axis:cce:req:v1";
+    readonly RESPONSE: "axis:cce:resp:v1";
+    readonly WITNESS: "axis:cce:witness:v1";
+};
+type CceAlgorithm = "AES-256-GCM";
+type CceKemAlgorithm = "X25519" | "RSA-OAEP-256";
+type CceKdfAlgorithm = "HKDF-SHA256";
+declare const CCE_AES_KEY_BYTES = 32;
+declare const CCE_IV_BYTES = 12;
+declare const CCE_TAG_BYTES = 16;
+declare const CCE_NONCE_BYTES = 32;
+interface CceCapsuleClaims {
+    capsule_id: string;
+    ver: typeof CCE_PROTOCOL_VERSION;
+    sub: string;
+    kid: string;
+    intent: string;
+    aud: string;
+    tps_from: number;
+    tps_to: number;
+    capsule_nonce: string;
+    challenge_id: string;
+    proof_hash?: string;
+    policy_hash?: string;
+    iat: number;
+    exp: number;
+    mode: "SINGLE_USE" | "SESSION";
+    scope?: string[];
+    constraints?: CceConstraints;
+    issuer_sig: CceSignature;
+}
+interface CceConstraints {
+    max_payload_bytes?: number;
+    ip_allow?: string[];
+    device_allow?: string[];
+    country_allow?: string[];
+}
+interface CceSignature {
+    alg: "EdDSA" | "ES256";
+    kid: string;
+    value: string;
+}
+interface CceRequestEnvelope {
+    ver: typeof CCE_PROTOCOL_VERSION;
+    request_id: string;
+    correlation_id: string;
+    client_kid: string;
+    capsule: CceCapsuleClaims;
+    encrypted_key: CceEncryptedKey;
+    encrypted_payload: CceEncryptedPayload;
+    request_nonce: string;
+    client_sig: CceSignature;
+    content_type: string;
+    algorithms: CceAlgorithmDescriptor;
+    aad_descriptor?: string;
+}
+interface CceEncryptedKey {
+    alg: CceKemAlgorithm;
+    axis_kid: string;
+    ciphertext: string;
+    ephemeral_pk?: string;
+}
+interface CceEncryptedPayload {
+    alg: CceAlgorithm;
+    iv: string;
+    ciphertext: string;
+    tag: string;
+}
+interface CceAlgorithmDescriptor {
+    kem: CceKemAlgorithm;
+    enc: CceAlgorithm;
+    kdf: CceKdfAlgorithm;
+    sig: "EdDSA" | "ES256";
+}
+interface CceResponseEnvelope {
+    ver: typeof CCE_PROTOCOL_VERSION;
+    response_id: string;
+    request_id: string;
+    correlation_id: string;
+    capsule_id: string;
+    encrypted_key: CceEncryptedKey;
+    encrypted_payload: CceEncryptedPayload;
+    response_nonce: string;
+    axis_sig: CceSignature;
+    witness_ref?: string;
+    algorithms: CceAlgorithmDescriptor;
+    status: CceResponseStatus;
+}
+type CceResponseStatus = "SUCCESS" | "DENIED" | "PARTIAL" | "FAILED" | "ERROR";
+interface CceExecutionContext {
+    execution_key_hash: string;
+    request_id: string;
+    capsule_id: string;
+    sub: string;
+    kid: string;
+    intent: string;
+    aud: string;
+    tps_from: number;
+    tps_to: number;
+    policy_hash?: string;
+    derived_at: number;
+    valid: boolean;
+}
+interface CceWitnessRecord {
+    witness_id: string;
+    request_id: string;
+    capsule_id: string;
+    sub: string;
+    intent: string;
+    aud: string;
+    tps_from: number;
+    tps_to: number;
+    timestamp: number;
+    verification: {
+        client_sig: boolean;
+        capsule_sig: boolean;
+        tps_valid: boolean;
+        audience_match: boolean;
+        intent_match: boolean;
+        replay_clean: boolean;
+        nonce_unique: boolean;
+        decryption_ok: boolean;
+    };
+    execution: {
+        status: CceResponseStatus;
+        handler_duration_ms: number;
+        effect?: string;
+    };
+    response_encrypted: boolean;
+    execution_context_hash: string;
+    request_payload_hash?: string;
+    response_payload_hash?: string;
+}
+declare const CCE_ERROR: {
+    readonly INVALID_ENVELOPE: "CCE_INVALID_ENVELOPE";
+    readonly UNSUPPORTED_VERSION: "CCE_UNSUPPORTED_VERSION";
+    readonly MISSING_CAPSULE: "CCE_MISSING_CAPSULE";
+    readonly MISSING_ENCRYPTED_KEY: "CCE_MISSING_ENCRYPTED_KEY";
+    readonly CLIENT_SIG_INVALID: "CCE_CLIENT_SIG_INVALID";
+    readonly CLIENT_KEY_NOT_FOUND: "CCE_CLIENT_KEY_NOT_FOUND";
+    readonly CAPSULE_SIG_INVALID: "CCE_CAPSULE_SIG_INVALID";
+    readonly CAPSULE_EXPIRED: "CCE_CAPSULE_EXPIRED";
+    readonly CAPSULE_NOT_YET_VALID: "CCE_CAPSULE_NOT_YET_VALID";
+    readonly CAPSULE_REVOKED: "CCE_CAPSULE_REVOKED";
+    readonly CAPSULE_CONSUMED: "CCE_CAPSULE_CONSUMED";
+    readonly AUDIENCE_MISMATCH: "CCE_AUDIENCE_MISMATCH";
+    readonly INTENT_MISMATCH: "CCE_INTENT_MISMATCH";
+    readonly TPS_WINDOW_EXPIRED: "CCE_TPS_WINDOW_EXPIRED";
+    readonly TPS_WINDOW_FUTURE: "CCE_TPS_WINDOW_FUTURE";
+    readonly REPLAY_DETECTED: "CCE_REPLAY_DETECTED";
+    readonly NONCE_REUSED: "CCE_NONCE_REUSED";
+    readonly DECRYPTION_FAILED: "CCE_DECRYPTION_FAILED";
+    readonly KEY_UNWRAP_FAILED: "CCE_KEY_UNWRAP_FAILED";
+    readonly AEAD_TAG_MISMATCH: "CCE_AEAD_TAG_MISMATCH";
+    readonly PAYLOAD_TOO_LARGE: "CCE_PAYLOAD_TOO_LARGE";
+    readonly PAYLOAD_SCHEMA_INVALID: "CCE_PAYLOAD_SCHEMA_INVALID";
+    readonly INTENT_SCHEMA_MISMATCH: "CCE_INTENT_SCHEMA_MISMATCH";
+    readonly POLICY_DENIED: "CCE_POLICY_DENIED";
+    readonly CONSTRAINT_VIOLATED: "CCE_CONSTRAINT_VIOLATED";
+    readonly HANDLER_NOT_FOUND: "CCE_HANDLER_NOT_FOUND";
+    readonly HANDLER_EXECUTION_FAILED: "CCE_HANDLER_EXECUTION_FAILED";
+    readonly HANDLER_TIMEOUT: "CCE_HANDLER_TIMEOUT";
+    readonly RESPONSE_ENCRYPTION_FAILED: "CCE_RESPONSE_ENCRYPTION_FAILED";
+};
+type CceErrorCode = (typeof CCE_ERROR)[keyof typeof CCE_ERROR];
+declare class CceError extends Error {
+    readonly code: CceErrorCode;
+    readonly metadata?: Record<string, unknown> | undefined;
+    constructor(code: CceErrorCode, message: string, metadata?: Record<string, unknown> | undefined);
+    get clientSafe(): boolean;
+    toClientError(): {
+        code: CceErrorCode;
+        message: string;
+    };
+}
+
+interface CceClientKeyEncryptor {
+    wrapKey(aesKey: Uint8Array, clientKid: string, clientPublicKeyHex: string): Promise<CceEncryptedKey>;
+}
+interface CceAxisSigner {
+    sign(payload: Uint8Array): Promise<CceSignature>;
+}
+interface CceResponseOptions {
+    request: CceRequestEnvelope;
+    capsule: CceCapsuleClaims;
+    status: CceResponseStatus;
+    body: Uint8Array;
+    clientPublicKeyHex: string;
+    witnessRef?: string;
+}
+declare function buildCceResponse(options: CceResponseOptions, clientKeyEncryptor: CceClientKeyEncryptor, axisSigner: CceAxisSigner): Promise<{
+    envelope: CceResponseEnvelope;
+    responsePayloadHash: string;
+}>;
+declare function buildCceErrorResponse(requestId: string, correlationId: string, status: CceResponseStatus, errorCode: string, message: string): {
+    ver: string;
+    request_id: string;
+    correlation_id: string;
+    status: CceResponseStatus;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+
+interface CceWitnessStore {
+    record(witness: CceWitnessRecord): Promise<void>;
+}
+declare class InMemoryCceWitnessStore implements CceWitnessStore {
+    readonly records: CceWitnessRecord[];
+    record(witness: CceWitnessRecord): Promise<void>;
+    getByRequestId(requestId: string): CceWitnessRecord | undefined;
+    getByCapsuleId(capsuleId: string): CceWitnessRecord[];
+}
+interface CceVerificationState {
+    clientSigVerified: boolean;
+    capsuleSigVerified: boolean;
+    tpsValid: boolean;
+    audienceMatch: boolean;
+    intentMatch: boolean;
+    replayClean: boolean;
+    nonceUnique: boolean;
+    decryptionOk: boolean;
+}
+declare function buildWitnessRecord(envelope: CceRequestEnvelope, capsule: CceCapsuleClaims, verification: CceVerificationState, execution: {
+    status: CceResponseStatus;
+    handlerDurationMs: number;
+    effect?: string;
+}, options: {
+    axisLocalSecret: string;
+    requestPayload?: Uint8Array;
+    responsePayload?: Uint8Array;
+    responseEncrypted: boolean;
+}): CceWitnessRecord;
+declare function extractVerificationState(metadata: Record<string, any>): CceVerificationState;
+
+type CceHandler = (payload: Uint8Array, context: CceHandlerContext) => Promise<CceHandlerResult>;
+interface CceHandlerContext {
+    capsule: CceCapsuleClaims;
+    executionContext: CceExecutionContext;
+    envelope: CceRequestEnvelope;
+    clientPublicKeyHex: string;
+    intent: string;
+    sub: string;
+}
+interface CceHandlerResult {
+    status: CceResponseStatus;
+    body: Uint8Array;
+    effect?: string;
+}
+interface CcePolicyContext {
+    envelope: CceRequestEnvelope;
+    capsule: CceCapsuleClaims;
+    executionContext: CceExecutionContext;
+    decryptedPayload: Uint8Array;
+    clientPublicKeyHex: string;
+}
+interface CcePolicyDecision {
+    allow: boolean;
+    code?: string;
+    message?: string;
+}
+interface CcePolicyEvaluator {
+    evaluate(context: CcePolicyContext): Promise<CcePolicyDecision>;
+}
+interface CcePipelineConfig {
+    axisLocalSecret: string;
+    axisAudience: string;
+    sensors: AxisSensor[];
+    handlers: Map<string, CceHandler>;
+    witnessStore: CceWitnessStore;
+    clientKeyEncryptor: CceClientKeyEncryptor;
+    axisSigner: CceAxisSigner;
+    policyEvaluator?: CcePolicyEvaluator;
+}
+type CcePipelineResult = {
+    ok: true;
+    response: CceResponseEnvelope;
+    witnessId: string;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+    status: CceResponseStatus;
+};
+declare function executeCcePipeline(envelope: CceRequestEnvelope, config: CcePipelineConfig): Promise<CcePipelineResult>;
+
+export { type CcePolicyDecision as A, type CcePolicyEvaluator as B, type CceCapsuleClaims as C, type CceResponseEnvelope as D, type CceResponseOptions as E, type CceResponseStatus as F, type CceSignature as G, type CceVerificationState as H, type CceWitnessRecord as I, type CceWitnessStore as J, InMemoryCceWitnessStore as K, buildCceErrorResponse as L, buildCceResponse as M, buildWitnessRecord as N, executeCcePipeline as O, extractVerificationState as P, type CceExecutionContext as a, type CceRequestEnvelope as b, CCE_AES_KEY_BYTES as c, CCE_DERIVATION as d, CCE_ERROR as e, CCE_IV_BYTES as f, CCE_NONCE_BYTES as g, CCE_PROTOCOL_VERSION as h, CCE_TAG_BYTES as i, type CceAlgorithm as j, type CceAlgorithmDescriptor as k, type CceAxisSigner as l, type CceClientKeyEncryptor as m, type CceConstraints as n, type CceEncryptedKey as o, type CceEncryptedPayload as p, CceError as q, type CceErrorCode as r, type CceHandler as s, type CceHandlerContext as t, type CceHandlerResult as u, type CceKdfAlgorithm as v, type CceKemAlgorithm as w, type CcePipelineConfig as x, type CcePipelineResult as y, type CcePolicyContext as z };

package/dist/idel/index.d.mts

@@ -0,0 +1,24 @@
+import { h as IntentSchema, f as IntentProposal, b as CompilationResult, c as CompiledIntent } from '../idel.types-DuUAcOnQ.mjs';
+export { A as AlternativeIntent, C as ClarificationQuestion, a as CompilationError, d as ConstraintKind, I as IntentConstraint, e as IntentParamSchema, g as IntentRisk, R as RiskLevel } from '../idel.types-DuUAcOnQ.mjs';
+
+declare class IdelSchemaRegistry {
+    private schemas;
+    private aliases;
+    register(schema: IntentSchema): void;
+    registerAlias(alias: string, intent: string): void;
+    get(intent: string): IntentSchema | undefined;
+    resolve(raw: string): IntentSchema | undefined;
+    findCandidates(raw: string): Array<{
+        schema: IntentSchema;
+        score: number;
+    }>;
+    list(): IntentSchema[];
+}
+declare class IdelCompiler {
+    private readonly registry;
+    constructor(registry: IdelSchemaRegistry);
+    compile(proposal: IntentProposal): CompilationResult;
+    applyClarifications(compiled: CompiledIntent, answers: Record<string, unknown>): CompilationResult;
+}
+
+export { CompilationResult, CompiledIntent, IdelCompiler, IdelSchemaRegistry, IntentProposal, IntentSchema };

package/dist/idel/index.d.ts

@@ -0,0 +1,24 @@
+import { h as IntentSchema, f as IntentProposal, b as CompilationResult, c as CompiledIntent } from '../idel.types-DuUAcOnQ.js';
+export { A as AlternativeIntent, C as ClarificationQuestion, a as CompilationError, d as ConstraintKind, I as IntentConstraint, e as IntentParamSchema, g as IntentRisk, R as RiskLevel } from '../idel.types-DuUAcOnQ.js';
+
+declare class IdelSchemaRegistry {
+    private schemas;
+    private aliases;
+    register(schema: IntentSchema): void;
+    registerAlias(alias: string, intent: string): void;
+    get(intent: string): IntentSchema | undefined;
+    resolve(raw: string): IntentSchema | undefined;
+    findCandidates(raw: string): Array<{
+        schema: IntentSchema;
+        score: number;
+    }>;
+    list(): IntentSchema[];
+}
+declare class IdelCompiler {
+    private readonly registry;
+    constructor(registry: IdelSchemaRegistry);
+    compile(proposal: IntentProposal): CompilationResult;
+    applyClarifications(compiled: CompiledIntent, answers: Record<string, unknown>): CompilationResult;
+}
+
+export { CompilationResult, CompiledIntent, IdelCompiler, IdelSchemaRegistry, IntentProposal, IntentSchema };

package/dist/idel/index.js

@@ -0,0 +1,306 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/idel/index.ts
+var idel_exports = {};
+__export(idel_exports, {
+  IdelCompiler: () => IdelCompiler,
+  IdelSchemaRegistry: () => IdelSchemaRegistry
+});
+module.exports = __toCommonJS(idel_exports);
+
+// src/idel/idel.compiler.ts
+var IdelSchemaRegistry = class {
+  constructor() {
+    this.schemas = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+  }
+  register(schema) {
+    this.schemas.set(schema.intent, schema);
+  }
+  registerAlias(alias, intent) {
+    this.aliases.set(alias.toLowerCase(), intent);
+  }
+  get(intent) {
+    return this.schemas.get(intent);
+  }
+  resolve(raw) {
+    const exact = this.schemas.get(raw);
+    if (exact) return exact;
+    const aliased = this.aliases.get(raw.toLowerCase());
+    if (aliased) return this.schemas.get(aliased);
+    const candidates = [...this.schemas.keys()].filter(
+      (k) => k.startsWith(raw + ".") || k.toLowerCase().includes(raw.toLowerCase())
+    );
+    if (candidates.length === 1) {
+      return this.schemas.get(candidates[0]);
+    }
+    return void 0;
+  }
+  /**
+   * Find all schemas that partially match the raw input.
+   * Returns scored candidates for ambiguity resolution.
+   */
+  findCandidates(raw) {
+    const normalized = raw.toLowerCase().trim();
+    const results = [];
+    for (const [key, schema] of this.schemas) {
+      let score = 0;
+      if (key === raw) {
+        score = 1;
+      } else if (key.toLowerCase() === normalized) {
+        score = 0.95;
+      } else if (this.aliases.get(normalized) === key) {
+        score = 0.9;
+      } else if (key.toLowerCase().startsWith(normalized)) {
+        score = 0.7;
+      } else if (key.toLowerCase().includes(normalized)) {
+        score = 0.5;
+      } else if (schema.tags?.some((t) => t.toLowerCase().includes(normalized))) {
+        score = 0.4;
+      } else if (schema.description.toLowerCase().includes(normalized)) {
+        score = 0.3;
+      }
+      if (score > 0) {
+        results.push({ schema, score });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score);
+  }
+  list() {
+    return [...this.schemas.values()];
+  }
+};
+var IdelCompiler = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Compile a raw intent proposal into a validated, executable structure.
+   */
+  compile(proposal) {
+    const errors = [];
+    const candidates = this.registry.findCandidates(proposal.raw);
+    if (candidates.length === 0) {
+      return {
+        ok: false,
+        errors: [{
+          code: "IDEL_UNKNOWN_INTENT",
+          message: `No intent found matching '${proposal.raw}'`
+        }]
+      };
+    }
+    const best = candidates[0];
+    const schema = best.schema;
+    const alternatives = candidates.slice(1, 4).filter((c) => c.score >= 0.3).map((c) => ({
+      intent: c.schema.intent,
+      confidence: c.score,
+      reason: c.schema.description
+    }));
+    const constraints = [];
+    const clarifications = [];
+    const params = { ...proposal.params };
+    for (const paramSchema of schema.params) {
+      const value = params[paramSchema.name];
+      if (paramSchema.required && value === void 0) {
+        if (paramSchema.default !== void 0) {
+          params[paramSchema.name] = paramSchema.default;
+          constraints.push({
+            kind: "required_param",
+            field: paramSchema.name,
+            description: `Defaulted to ${JSON.stringify(paramSchema.default)}`,
+            satisfied: true,
+            value: paramSchema.default
+          });
+        } else {
+          constraints.push({
+            kind: "required_param",
+            field: paramSchema.name,
+            description: `Required parameter '${paramSchema.name}' is missing`,
+            satisfied: false
+          });
+          clarifications.push({
+            id: `clarify_${paramSchema.name}`,
+            question: paramSchema.description ?? `What is the ${paramSchema.name}?`,
+            field: paramSchema.name,
+            options: paramSchema.enum?.map(String),
+            required: true
+          });
+        }
+        continue;
+      }
+      if (value === void 0) continue;
+      const typeValid = validateType(value, paramSchema.type);
+      constraints.push({
+        kind: "type_check",
+        field: paramSchema.name,
+        description: `Must be ${paramSchema.type}`,
+        satisfied: typeValid,
+        value,
+        expected: paramSchema.type
+      });
+      if (!typeValid) {
+        errors.push({
+          code: "IDEL_TYPE_ERROR",
+          message: `Parameter '${paramSchema.name}' must be ${paramSchema.type}, got ${typeof value}`,
+          field: paramSchema.name
+        });
+      }
+      if (paramSchema.min !== void 0 || paramSchema.max !== void 0) {
+        const numVal = typeof value === "number" ? value : Number(value);
+        const inRange = (paramSchema.min === void 0 || numVal >= paramSchema.min) && (paramSchema.max === void 0 || numVal <= paramSchema.max);
+        constraints.push({
+          kind: "range",
+          field: paramSchema.name,
+          description: `Must be between ${paramSchema.min ?? "-\u221E"} and ${paramSchema.max ?? "\u221E"}`,
+          satisfied: inRange,
+          value: numVal
+        });
+      }
+      if (paramSchema.pattern) {
+        const matches = new RegExp(paramSchema.pattern).test(String(value));
+        constraints.push({
+          kind: "pattern",
+          field: paramSchema.name,
+          description: `Must match ${paramSchema.pattern}`,
+          satisfied: matches,
+          value,
+          expected: paramSchema.pattern
+        });
+      }
+      if (paramSchema.enum) {
+        const inEnum = paramSchema.enum.some(
+          (e) => JSON.stringify(e) === JSON.stringify(value)
+        );
+        constraints.push({
+          kind: "custom",
+          field: paramSchema.name,
+          description: `Must be one of: ${paramSchema.enum.join(", ")}`,
+          satisfied: inEnum,
+          value,
+          expected: paramSchema.enum
+        });
+      }
+    }
+    const risk = assessRisk(schema, proposal, constraints);
+    const unsatisfied = constraints.filter((c) => !c.satisfied);
+    const needsClarification = clarifications.length > 0;
+    let confidence = best.score;
+    if (unsatisfied.length > 0) {
+      confidence *= 1 - unsatisfied.length / Math.max(constraints.length, 1) * 0.5;
+    }
+    if (errors.length > 0) {
+      confidence *= 0.5;
+    }
+    const compiled = {
+      intent: schema.intent,
+      actor_id: proposal.actor_id,
+      target: proposal.target,
+      params,
+      constraints,
+      confidence,
+      alternatives,
+      needs_clarification: needsClarification,
+      clarifications,
+      expected_outcome: schema.description,
+      fallback: schema.related?.[0],
+      risk,
+      metadata: {
+        schema_intent: schema.intent,
+        resolved_from: proposal.raw,
+        has_side_effects: schema.has_side_effects,
+        reversible: schema.reversible
+      }
+    };
+    return {
+      ok: errors.length === 0 && !needsClarification,
+      compiled,
+      errors
+    };
+  }
+  /**
+   * Apply clarification answers and re-compile.
+   */
+  applyClarifications(compiled, answers) {
+    const proposal = {
+      raw: compiled.intent,
+      actor_id: compiled.actor_id,
+      target: compiled.target,
+      params: { ...compiled.params, ...answers }
+    };
+    return this.compile(proposal);
+  }
+};
+function validateType(value, expectedType) {
+  switch (expectedType) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    default:
+      return true;
+  }
+}
+function assessRisk(schema, proposal, constraints) {
+  const factors = [];
+  let score = 0;
+  const baseRiskMap = {
+    none: 0,
+    low: 0.1,
+    medium: 0.3,
+    high: 0.6,
+    critical: 0.9
+  };
+  score = baseRiskMap[schema.risk_level] ?? 0;
+  if (schema.risk_level !== "none") {
+    factors.push(`Base risk: ${schema.risk_level}`);
+  }
+  if (schema.has_side_effects) {
+    score += 0.1;
+    factors.push("Has side effects");
+  }
+  if (!schema.reversible) {
+    score += 0.1;
+    factors.push("Not reversible");
+  }
+  const failed = constraints.filter((c) => !c.satisfied);
+  if (failed.length > 0) {
+    score += 0.05 * failed.length;
+    factors.push(`${failed.length} unsatisfied constraint(s)`);
+  }
+  score = Math.min(score, 1);
+  let level;
+  if (score <= 0) level = "none";
+  else if (score <= 0.2) level = "low";
+  else if (score <= 0.5) level = "medium";
+  else if (score <= 0.8) level = "high";
+  else level = "critical";
+  return { level, score, factors };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IdelCompiler,
+  IdelSchemaRegistry
+});
+//# sourceMappingURL=index.js.map

package/dist/idel/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/idel/index.ts","../../src/idel/idel.compiler.ts"],"sourcesContent":["export * from './idel.types';\nexport * from './idel.compiler';\n","/**\n * IDEL Compiler — Intent Description & Execution Language\n *\n * Compiles raw intent proposals into validated, executable structures.\n *\n * Pipeline:\n *   1. Resolve: match raw input to a known intent schema\n *   2. Validate: check all required params and constraints\n *   3. Assess risk: evaluate intent risk level\n *   4. Generate clarifications: if ambiguous or incomplete\n *   5. Output: CompiledIntent ready for AXIS execution\n */\n\nimport type {\n  AlternativeIntent,\n  ClarificationQuestion,\n  CompilationError,\n  CompilationResult,\n  CompiledIntent,\n  IntentConstraint,\n  IntentParamSchema,\n  IntentProposal,\n  IntentRisk,\n  IntentSchema,\n  RiskLevel,\n} from './idel.types';\n\n// ────────────────────────────────────────────────────────────────────────────\n// Schema Registry\n// ────────────────────────────────────────────────────────────────────────────\n\nexport class IdelSchemaRegistry {\n  private schemas = new Map<string, IntentSchema>();\n  private aliases = new Map<string, string>();\n\n  register(schema: IntentSchema): void {\n    this.schemas.set(schema.intent, schema);\n  }\n\n  registerAlias(alias: string, intent: string): void {\n    this.aliases.set(alias.toLowerCase(), intent);\n  }\n\n  get(intent: string): IntentSchema | undefined {\n    return this.schemas.get(intent);\n  }\n\n  resolve(raw: string): IntentSchema | undefined {\n    // Exact match\n    const exact = this.schemas.get(raw);\n    if (exact) return exact;\n\n    // Alias match\n    const aliased = this.aliases.get(raw.toLowerCase());\n    if (aliased) return this.schemas.get(aliased);\n\n    // Prefix match (e.g., \"payment\" → \"payment.create\")\n    const candidates = [...this.schemas.keys()].filter(\n      (k) => k.startsWith(raw + '.') || k.toLowerCase().includes(raw.toLowerCase()),\n    );\n    if (candidates.length === 1) {\n      return this.schemas.get(candidates[0]);\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Find all schemas that partially match the raw input.\n   * Returns scored candidates for ambiguity resolution.\n   */\n  findCandidates(raw: string): Array<{ schema: IntentSchema; score: number }> {\n    const normalized = raw.toLowerCase().trim();\n    const results: Array<{ schema: IntentSchema; score: number }> = [];\n\n    for (const [key, schema] of this.schemas) {\n      let score = 0;\n\n      // Exact match\n      if (key === raw) {\n        score = 1.0;\n      }\n      // Case-insensitive exact\n      else if (key.toLowerCase() === normalized) {\n        score = 0.95;\n      }\n      // Alias match\n      else if (this.aliases.get(normalized) === key) {\n        score = 0.9;\n      }\n      // Prefix match\n      else if (key.toLowerCase().startsWith(normalized)) {\n        score = 0.7;\n      }\n      // Contains match\n      else if (key.toLowerCase().includes(normalized)) {\n        score = 0.5;\n      }\n      // Tag match\n      else if (schema.tags?.some((t) => t.toLowerCase().includes(normalized))) {\n        score = 0.4;\n      }\n      // Description match\n      else if (schema.description.toLowerCase().includes(normalized)) {\n        score = 0.3;\n      }\n\n      if (score > 0) {\n        results.push({ schema, score });\n      }\n    }\n\n    return results.sort((a, b) => b.score - a.score);\n  }\n\n  list(): IntentSchema[] {\n    return [...this.schemas.values()];\n  }\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// IDEL Compiler\n// ────────────────────────────────────────────────────────────────────────────\n\nexport class IdelCompiler {\n  constructor(private readonly registry: IdelSchemaRegistry) {}\n\n  /**\n   * Compile a raw intent proposal into a validated, executable structure.\n   */\n  compile(proposal: IntentProposal): CompilationResult {\n    const errors: CompilationError[] = [];\n\n    // 1. Resolve intent\n    const candidates = this.registry.findCandidates(proposal.raw);\n    if (candidates.length === 0) {\n      return {\n        ok: false,\n        errors: [{\n          code: 'IDEL_UNKNOWN_INTENT',\n          message: `No intent found matching '${proposal.raw}'`,\n        }],\n      };\n    }\n\n    const best = candidates[0];\n    const schema = best.schema;\n\n    // 2. Build alternatives\n    const alternatives: AlternativeIntent[] = candidates\n      .slice(1, 4)\n      .filter((c) => c.score >= 0.3)\n      .map((c) => ({\n        intent: c.schema.intent,\n        confidence: c.score,\n        reason: c.schema.description,\n      }));\n\n    // 3. Validate parameters\n    const constraints: IntentConstraint[] = [];\n    const clarifications: ClarificationQuestion[] = [];\n    const params = { ...proposal.params };\n\n    for (const paramSchema of schema.params) {\n      const value = params[paramSchema.name];\n\n      // Required check\n      if (paramSchema.required && value === undefined) {\n        if (paramSchema.default !== undefined) {\n          params[paramSchema.name] = paramSchema.default;\n          constraints.push({\n            kind: 'required_param',\n            field: paramSchema.name,\n            description: `Defaulted to ${JSON.stringify(paramSchema.default)}`,\n            satisfied: true,\n            value: paramSchema.default,\n          });\n        } else {\n          constraints.push({\n            kind: 'required_param',\n            field: paramSchema.name,\n            description: `Required parameter '${paramSchema.name}' is missing`,\n            satisfied: false,\n          });\n          clarifications.push({\n            id: `clarify_${paramSchema.name}`,\n            question: paramSchema.description ?? `What is the ${paramSchema.name}?`,\n            field: paramSchema.name,\n            options: paramSchema.enum?.map(String),\n            required: true,\n          });\n        }\n        continue;\n      }\n\n      if (value === undefined) continue;\n\n      // Type check\n      const typeValid = validateType(value, paramSchema.type);\n      constraints.push({\n        kind: 'type_check',\n        field: paramSchema.name,\n        description: `Must be ${paramSchema.type}`,\n        satisfied: typeValid,\n        value,\n        expected: paramSchema.type,\n      });\n      if (!typeValid) {\n        errors.push({\n          code: 'IDEL_TYPE_ERROR',\n          message: `Parameter '${paramSchema.name}' must be ${paramSchema.type}, got ${typeof value}`,\n          field: paramSchema.name,\n        });\n      }\n\n      // Range check\n      if (paramSchema.min !== undefined || paramSchema.max !== undefined) {\n        const numVal = typeof value === 'number' ? value : Number(value);\n        const inRange =\n          (paramSchema.min === undefined || numVal >= paramSchema.min) &&\n          (paramSchema.max === undefined || numVal <= paramSchema.max);\n        constraints.push({\n          kind: 'range',\n          field: paramSchema.name,\n          description: `Must be between ${paramSchema.min ?? '-∞'} and ${paramSchema.max ?? '∞'}`,\n          satisfied: inRange,\n          value: numVal,\n        });\n      }\n\n      // Pattern check\n      if (paramSchema.pattern) {\n        const matches = new RegExp(paramSchema.pattern).test(String(value));\n        constraints.push({\n          kind: 'pattern',\n          field: paramSchema.name,\n          description: `Must match ${paramSchema.pattern}`,\n          satisfied: matches,\n          value,\n          expected: paramSchema.pattern,\n        });\n      }\n\n      // Enum check\n      if (paramSchema.enum) {\n        const inEnum = paramSchema.enum.some(\n          (e) => JSON.stringify(e) === JSON.stringify(value),\n        );\n        constraints.push({\n          kind: 'custom',\n          field: paramSchema.name,\n          description: `Must be one of: ${paramSchema.enum.join(', ')}`,\n          satisfied: inEnum,\n          value,\n          expected: paramSchema.enum,\n        });\n      }\n    }\n\n    // 4. Assess risk\n    const risk = assessRisk(schema, proposal, constraints);\n\n    // 5. Compute confidence\n    const unsatisfied = constraints.filter((c) => !c.satisfied);\n    const needsClarification = clarifications.length > 0;\n    let confidence = best.score;\n    if (unsatisfied.length > 0) {\n      confidence *= 1 - (unsatisfied.length / Math.max(constraints.length, 1)) * 0.5;\n    }\n    if (errors.length > 0) {\n      confidence *= 0.5;\n    }\n\n    const compiled: CompiledIntent = {\n      intent: schema.intent,\n      actor_id: proposal.actor_id,\n      target: proposal.target,\n      params,\n      constraints,\n      confidence,\n      alternatives,\n      needs_clarification: needsClarification,\n      clarifications,\n      expected_outcome: schema.description,\n      fallback: schema.related?.[0],\n      risk,\n      metadata: {\n        schema_intent: schema.intent,\n        resolved_from: proposal.raw,\n        has_side_effects: schema.has_side_effects,\n        reversible: schema.reversible,\n      },\n    };\n\n    return {\n      ok: errors.length === 0 && !needsClarification,\n      compiled,\n      errors,\n    };\n  }\n\n  /**\n   * Apply clarification answers and re-compile.\n   */\n  applyClarifications(\n    compiled: CompiledIntent,\n    answers: Record<string, unknown>,\n  ): CompilationResult {\n    const proposal: IntentProposal = {\n      raw: compiled.intent,\n      actor_id: compiled.actor_id,\n      target: compiled.target,\n      params: { ...compiled.params, ...answers },\n    };\n    return this.compile(proposal);\n  }\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// Helpers\n// ────────────────────────────────────────────────────────────────────────────\n\nfunction validateType(value: unknown, expectedType: IntentParamSchema['type']): boolean {\n  switch (expectedType) {\n    case 'string':\n      return typeof value === 'string';\n    case 'number':\n      return typeof value === 'number' && Number.isFinite(value);\n    case 'boolean':\n      return typeof value === 'boolean';\n    case 'object':\n      return typeof value === 'object' && value !== null && !Array.isArray(value);\n    case 'array':\n      return Array.isArray(value);\n    default:\n      return true;\n  }\n}\n\nfunction assessRisk(\n  schema: IntentSchema,\n  proposal: IntentProposal,\n  constraints: IntentConstraint[],\n): IntentRisk {\n  const factors: string[] = [];\n  let score = 0;\n\n  // Base risk from schema\n  const baseRiskMap: Record<RiskLevel, number> = {\n    none: 0,\n    low: 0.1,\n    medium: 0.3,\n    high: 0.6,\n    critical: 0.9,\n  };\n  score = baseRiskMap[schema.risk_level] ?? 0;\n  if (schema.risk_level !== 'none') {\n    factors.push(`Base risk: ${schema.risk_level}`);\n  }\n\n  // Side effects increase risk\n  if (schema.has_side_effects) {\n    score += 0.1;\n    factors.push('Has side effects');\n  }\n\n  // Irreversible actions increase risk\n  if (!schema.reversible) {\n    score += 0.1;\n    factors.push('Not reversible');\n  }\n\n  // Failed constraints increase risk\n  const failed = constraints.filter((c) => !c.satisfied);\n  if (failed.length > 0) {\n    score += 0.05 * failed.length;\n    factors.push(`${failed.length} unsatisfied constraint(s)`);\n  }\n\n  // Clamp\n  score = Math.min(score, 1.0);\n\n  let level: RiskLevel;\n  if (score <= 0) level = 'none';\n  else if (score <= 0.2) level = 'low';\n  else if (score <= 0.5) level = 'medium';\n  else if (score <= 0.8) level = 'high';\n  else level = 'critical';\n\n  return { level, score, factors };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC+BO,IAAM,qBAAN,MAAyB;AAAA,EAAzB;AACL,SAAQ,UAAU,oBAAI,IAA0B;AAChD,SAAQ,UAAU,oBAAI,IAAoB;AAAA;AAAA,EAE1C,SAAS,QAA4B;AACnC,SAAK,QAAQ,IAAI,OAAO,QAAQ,MAAM;AAAA,EACxC;AAAA,EAEA,cAAc,OAAe,QAAsB;AACjD,SAAK,QAAQ,IAAI,MAAM,YAAY,GAAG,MAAM;AAAA,EAC9C;AAAA,EAEA,IAAI,QAA0C;AAC5C,WAAO,KAAK,QAAQ,IAAI,MAAM;AAAA,EAChC;AAAA,EAEA,QAAQ,KAAuC;AAE7C,UAAM,QAAQ,KAAK,QAAQ,IAAI,GAAG;AAClC,QAAI,MAAO,QAAO;AAGlB,UAAM,UAAU,KAAK,QAAQ,IAAI,IAAI,YAAY,CAAC;AAClD,QAAI,QAAS,QAAO,KAAK,QAAQ,IAAI,OAAO;AAG5C,UAAM,aAAa,CAAC,GAAG,KAAK,QAAQ,KAAK,CAAC,EAAE;AAAA,MAC1C,CAAC,MAAM,EAAE,WAAW,MAAM,GAAG,KAAK,EAAE,YAAY,EAAE,SAAS,IAAI,YAAY,CAAC;AAAA,IAC9E;AACA,QAAI,WAAW,WAAW,GAAG;AAC3B,aAAO,KAAK,QAAQ,IAAI,WAAW,CAAC,CAAC;AAAA,IACvC;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,eAAe,KAA6D;AAC1E,UAAM,aAAa,IAAI,YAAY,EAAE,KAAK;AAC1C,UAAM,UAA0D,CAAC;AAEjE,eAAW,CAAC,KAAK,MAAM,KAAK,KAAK,SAAS;AACxC,UAAI,QAAQ;AAGZ,UAAI,QAAQ,KAAK;AACf,gBAAQ;AAAA,MACV,WAES,IAAI,YAAY,MAAM,YAAY;AACzC,gBAAQ;AAAA,MACV,WAES,KAAK,QAAQ,IAAI,UAAU,MAAM,KAAK;AAC7C,gBAAQ;AAAA,MACV,WAES,IAAI,YAAY,EAAE,WAAW,UAAU,GAAG;AACjD,gBAAQ;AAAA,MACV,WAES,IAAI,YAAY,EAAE,SAAS,UAAU,GAAG;AAC/C,gBAAQ;AAAA,MACV,WAES,OAAO,MAAM,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,UAAU,CAAC,GAAG;AACvE,gBAAQ;AAAA,MACV,WAES,OAAO,YAAY,YAAY,EAAE,SAAS,UAAU,GAAG;AAC9D,gBAAQ;AAAA,MACV;AAEA,UAAI,QAAQ,GAAG;AACb,gBAAQ,KAAK,EAAE,QAAQ,MAAM,CAAC;AAAA,MAChC;AAAA,IACF;AAEA,WAAO,QAAQ,KAAK,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;AAAA,EACjD;AAAA,EAEA,OAAuB;AACrB,WAAO,CAAC,GAAG,KAAK,QAAQ,OAAO,CAAC;AAAA,EAClC;AACF;AAMO,IAAM,eAAN,MAAmB;AAAA,EACxB,YAA6B,UAA8B;AAA9B;AAAA,EAA+B;AAAA;AAAA;AAAA;AAAA,EAK5D,QAAQ,UAA6C;AACnD,UAAM,SAA6B,CAAC;AAGpC,UAAM,aAAa,KAAK,SAAS,eAAe,SAAS,GAAG;AAC5D,QAAI,WAAW,WAAW,GAAG;AAC3B,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ,CAAC;AAAA,UACP,MAAM;AAAA,UACN,SAAS,6BAA6B,SAAS,GAAG;AAAA,QACpD,CAAC;AAAA,MACH;AAAA,IACF;AAEA,UAAM,OAAO,WAAW,CAAC;AACzB,UAAM,SAAS,KAAK;AAGpB,UAAM,eAAoC,WACvC,MAAM,GAAG,CAAC,EACV,OAAO,CAAC,MAAM,EAAE,SAAS,GAAG,EAC5B,IAAI,CAAC,OAAO;AAAA,MACX,QAAQ,EAAE,OAAO;AAAA,MACjB,YAAY,EAAE;AAAA,MACd,QAAQ,EAAE,OAAO;AAAA,IACnB,EAAE;AAGJ,UAAM,cAAkC,CAAC;AACzC,UAAM,iBAA0C,CAAC;AACjD,UAAM,SAAS,EAAE,GAAG,SAAS,OAAO;AAEpC,eAAW,eAAe,OAAO,QAAQ;AACvC,YAAM,QAAQ,OAAO,YAAY,IAAI;AAGrC,UAAI,YAAY,YAAY,UAAU,QAAW;AAC/C,YAAI,YAAY,YAAY,QAAW;AACrC,iBAAO,YAAY,IAAI,IAAI,YAAY;AACvC,sBAAY,KAAK;AAAA,YACf,MAAM;AAAA,YACN,OAAO,YAAY;AAAA,YACnB,aAAa,gBAAgB,KAAK,UAAU,YAAY,OAAO,CAAC;AAAA,YAChE,WAAW;AAAA,YACX,OAAO,YAAY;AAAA,UACrB,CAAC;AAAA,QACH,OAAO;AACL,sBAAY,KAAK;AAAA,YACf,MAAM;AAAA,YACN,OAAO,YAAY;AAAA,YACnB,aAAa,uBAAuB,YAAY,IAAI;AAAA,YACpD,WAAW;AAAA,UACb,CAAC;AACD,yBAAe,KAAK;AAAA,YAClB,IAAI,WAAW,YAAY,IAAI;AAAA,YAC/B,UAAU,YAAY,eAAe,eAAe,YAAY,IAAI;AAAA,YACpE,OAAO,YAAY;AAAA,YACnB,SAAS,YAAY,MAAM,IAAI,MAAM;AAAA,YACrC,UAAU;AAAA,UACZ,CAAC;AAAA,QACH;AACA;AAAA,MACF;AAEA,UAAI,UAAU,OAAW;AAGzB,YAAM,YAAY,aAAa,OAAO,YAAY,IAAI;AACtD,kBAAY,KAAK;AAAA,QACf,MAAM;AAAA,QACN,OAAO,YAAY;AAAA,QACnB,aAAa,WAAW,YAAY,IAAI;AAAA,QACxC,WAAW;AAAA,QACX;AAAA,QACA,UAAU,YAAY;AAAA,MACxB,CAAC;AACD,UAAI,CAAC,WAAW;AACd,eAAO,KAAK;AAAA,UACV,MAAM;AAAA,UACN,SAAS,cAAc,YAAY,IAAI,aAAa,YAAY,IAAI,SAAS,OAAO,KAAK;AAAA,UACzF,OAAO,YAAY;AAAA,QACrB,CAAC;AAAA,MACH;AAGA,UAAI,YAAY,QAAQ,UAAa,YAAY,QAAQ,QAAW;AAClE,cAAM,SAAS,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;AAC/D,cAAM,WACH,YAAY,QAAQ,UAAa,UAAU,YAAY,SACvD,YAAY,QAAQ,UAAa,UAAU,YAAY;AAC1D,oBAAY,KAAK;AAAA,UACf,MAAM;AAAA,UACN,OAAO,YAAY;AAAA,UACnB,aAAa,mBAAmB,YAAY,OAAO,SAAI,QAAQ,YAAY,OAAO,QAAG;AAAA,UACrF,WAAW;AAAA,UACX,OAAO;AAAA,QACT,CAAC;AAAA,MACH;AAGA,UAAI,YAAY,SAAS;AACvB,cAAM,UAAU,IAAI,OAAO,YAAY,OAAO,EAAE,KAAK,OAAO,KAAK,CAAC;AAClE,oBAAY,KAAK;AAAA,UACf,MAAM;AAAA,UACN,OAAO,YAAY;AAAA,UACnB,aAAa,cAAc,YAAY,OAAO;AAAA,UAC9C,WAAW;AAAA,UACX;AAAA,UACA,UAAU,YAAY;AAAA,QACxB,CAAC;AAAA,MACH;AAGA,UAAI,YAAY,MAAM;AACpB,cAAM,SAAS,YAAY,KAAK;AAAA,UAC9B,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM,KAAK,UAAU,KAAK;AAAA,QACnD;AACA,oBAAY,KAAK;AAAA,UACf,MAAM;AAAA,UACN,OAAO,YAAY;AAAA,UACnB,aAAa,mBAAmB,YAAY,KAAK,KAAK,IAAI,CAAC;AAAA,UAC3D,WAAW;AAAA,UACX;AAAA,UACA,UAAU,YAAY;AAAA,QACxB,CAAC;AAAA,MACH;AAAA,IACF;AAGA,UAAM,OAAO,WAAW,QAAQ,UAAU,WAAW;AAGrD,UAAM,cAAc,YAAY,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS;AAC1D,UAAM,qBAAqB,eAAe,SAAS;AACnD,QAAI,aAAa,KAAK;AACtB,QAAI,YAAY,SAAS,GAAG;AAC1B,oBAAc,IAAK,YAAY,SAAS,KAAK,IAAI,YAAY,QAAQ,CAAC,IAAK;AAAA,IAC7E;AACA,QAAI,OAAO,SAAS,GAAG;AACrB,oBAAc;AAAA,IAChB;AAEA,UAAM,WAA2B;AAAA,MAC/B,QAAQ,OAAO;AAAA,MACf,UAAU,SAAS;AAAA,MACnB,QAAQ,SAAS;AAAA,MACjB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,qBAAqB;AAAA,MACrB;AAAA,MACA,kBAAkB,OAAO;AAAA,MACzB,UAAU,OAAO,UAAU,CAAC;AAAA,MAC5B;AAAA,MACA,UAAU;AAAA,QACR,eAAe,OAAO;AAAA,QACtB,eAAe,SAAS;AAAA,QACxB,kBAAkB,OAAO;AAAA,QACzB,YAAY,OAAO;AAAA,MACrB;AAAA,IACF;AAEA,WAAO;AAAA,MACL,IAAI,OAAO,WAAW,KAAK,CAAC;AAAA,MAC5B;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,oBACE,UACA,SACmB;AACnB,UAAM,WAA2B;AAAA,MAC/B,KAAK,SAAS;AAAA,MACd,UAAU,SAAS;AAAA,MACnB,QAAQ,SAAS;AAAA,MACjB,QAAQ,EAAE,GAAG,SAAS,QAAQ,GAAG,QAAQ;AAAA,IAC3C;AACA,WAAO,KAAK,QAAQ,QAAQ;AAAA,EAC9B;AACF;AAMA,SAAS,aAAa,OAAgB,cAAkD;AACtF,UAAQ,cAAc;AAAA,IACpB,KAAK;AACH,aAAO,OAAO,UAAU;AAAA,IAC1B,KAAK;AACH,aAAO,OAAO,UAAU,YAAY,OAAO,SAAS,KAAK;AAAA,IAC3D,KAAK;AACH,aAAO,OAAO,UAAU;AAAA,IAC1B,KAAK;AACH,aAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAAA,IAC5E,KAAK;AACH,aAAO,MAAM,QAAQ,KAAK;AAAA,IAC5B;AACE,aAAO;AAAA,EACX;AACF;AAEA,SAAS,WACP,QACA,UACA,aACY;AACZ,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AAGZ,QAAM,cAAyC;AAAA,IAC7C,MAAM;AAAA,IACN,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,UAAU;AAAA,EACZ;AACA,UAAQ,YAAY,OAAO,UAAU,KAAK;AAC1C,MAAI,OAAO,eAAe,QAAQ;AAChC,YAAQ,KAAK,cAAc,OAAO,UAAU,EAAE;AAAA,EAChD;AAGA,MAAI,OAAO,kBAAkB;AAC3B,aAAS;AACT,YAAQ,KAAK,kBAAkB;AAAA,EACjC;AAGA,MAAI,CAAC,OAAO,YAAY;AACtB,aAAS;AACT,YAAQ,KAAK,gBAAgB;AAAA,EAC/B;AAGA,QAAM,SAAS,YAAY,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS;AACrD,MAAI,OAAO,SAAS,GAAG;AACrB,aAAS,OAAO,OAAO;AACvB,YAAQ,KAAK,GAAG,OAAO,MAAM,4BAA4B;AAAA,EAC3D;AAGA,UAAQ,KAAK,IAAI,OAAO,CAAG;AAE3B,MAAI;AACJ,MAAI,SAAS,EAAG,SAAQ;AAAA,WACf,SAAS,IAAK,SAAQ;AAAA,WACtB,SAAS,IAAK,SAAQ;AAAA,WACtB,SAAS,IAAK,SAAQ;AAAA,MAC1B,SAAQ;AAEb,SAAO,EAAE,OAAO,OAAO,QAAQ;AACjC;","names":[]}