@intentic/sandbox-contract 1.333.1 → 1.335.0

package/dist/contracts/audit.contract.d.ts

@@ -0,0 +1,84 @@
+export declare const auditContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        from: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        to: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        action: import("zod").ZodOptional<import("zod").ZodString>;
+        actor: import("zod").ZodOptional<import("zod").ZodString>;
+        target: import("zod").ZodOptional<import("zod").ZodString>;
+        before: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        records: import("zod").ZodArray<import("zod").ZodObject<{
+            actor: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"member">;
+                email: import("zod").ZodString;
+                role: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"token">;
+                id: import("zod").ZodString;
+                label: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"agent">;
+                conversationId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"system">;
+                reason: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>], "kind">;
+            action: import("zod").ZodString;
+            target: import("zod").ZodOptional<import("zod").ZodString>;
+            outcome: import("zod").ZodOptional<import("zod").ZodEnum<{
+                failed: "failed";
+                ok: "ok";
+                refused: "refused";
+            }>>;
+            details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            v: import("zod").ZodLiteral<1>;
+            id: import("zod").ZodString;
+            at: import("zod").ZodNumber;
+            prevHash: import("zod").ZodString;
+            hash: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        next: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+    verify: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        ok: import("zod").ZodBoolean;
+        checked: import("zod").ZodNumber;
+        segments: import("zod").ZodNumber;
+        prunedThrough: import("zod").ZodOptional<import("zod").ZodObject<{
+            at: import("zod").ZodNumber;
+            hash: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        broken: import("zod").ZodOptional<import("zod").ZodObject<{
+            segment: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            at: import("zod").ZodOptional<import("zod").ZodNumber>;
+            reason: import("zod").ZodEnum<{
+                "chain-break": "chain-break";
+                "hash-mismatch": "hash-mismatch";
+                unreadable: "unreadable";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+        torn: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+    export: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        from: import("zod").ZodCoercedNumber<unknown>;
+        to: import("zod").ZodCoercedNumber<unknown>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        filename: import("zod").ZodString;
+        jsonl: import("zod").ZodString;
+        count: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+    status: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        forwarding: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            pending: import("zod").ZodNumber;
+            lastSentAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lastError: import("zod").ZodOptional<import("zod").ZodString>;
+            nextAttemptAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        oldestAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+        segments: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+};
+//# sourceMappingURL=audit.contract.d.ts.map

package/dist/contracts/audit.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/audit.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;IACtB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWJ,MAAM;;;;;;;;;;;;;;;;;;;;;IAUN,MAAM;;;;;;;;IAUN,MAAM;;;;;;;;;;;CAST,CAAC"}

package/dist/contracts/audit.contract.js

@@ -0,0 +1,43 @@
+import { procedure } from "../protocol/route-meta.js";
+import { AuditExportQuerySchema, AuditExportSchema, AuditListSchema, AuditQuerySchema, AuditStatusSchema, AuditVerifySchema } from "../schemas/audit.js";
+export const auditContract = {
+    list: procedure
+        .route({
+        method: "GET",
+        path: "/audit",
+        summary: "The audit trail",
+        description: "Who changed a setting, a member, a secret's gate or a policy, who signed in, and, when reads are recorded, who opened what. Newest first, filtered and paged. Reading it is itself recorded when reads are.",
+    })
+        .meta({ floor: "maintainer" })
+        .input(AuditQuerySchema)
+        .output(AuditListSchema),
+    verify: procedure
+        .route({
+        method: "GET",
+        path: "/audit/verify",
+        summary: "Check the audit trail for tampering",
+        description: "Recomputes every record's hash and its link to the one before it. Names the first record that was changed, removed or inserted after it was written. It shows tampering; it cannot undo it, which is what the copy sent to a forward address is for.",
+    })
+        .meta({ floor: "maintainer" })
+        .output(AuditVerifySchema),
+    export: procedure
+        .route({
+        method: "GET",
+        path: "/audit/export",
+        summary: "Download the audit trail for a period",
+        description: "The records written in a period as JSON Lines, exactly as stored, so whoever receives them can check the hashes themselves.",
+    })
+        .meta({ floor: "maintainer" })
+        .input(AuditExportQuerySchema)
+        .output(AuditExportSchema),
+    status: procedure
+        .route({
+        method: "GET",
+        path: "/audit/status",
+        summary: "Whether the audit trail's outside copy keeps up",
+        description: "Which monthly files are kept, the oldest record, and whether records are reaching the forward address.",
+    })
+        .meta({ floor: "maintainer" })
+        .output(AuditStatusSchema),
+};
+//# sourceMappingURL=audit.contract.js.map

package/dist/contracts/audit.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.contract.js","sourceRoot":"","sources":["../../src/contracts/audit.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAKzJ,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB,IAAI,EAAE,SAAS;SACV,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,iBAAiB;QAC1B,WAAW,EACP,6MAA6M;KACpN,CAAC;SACD,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;SAC7B,KAAK,CAAC,gBAAgB,CAAC;SACvB,MAAM,CAAC,eAAe,CAAC;IAC5B,MAAM,EAAE,SAAS;SACZ,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,qCAAqC;QAC9C,WAAW,EACP,sPAAsP;KAC7P,CAAC;SACD,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;SAC7B,MAAM,CAAC,iBAAiB,CAAC;IAC9B,MAAM,EAAE,SAAS;SACZ,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,uCAAuC;QAChD,WAAW,EAAE,6HAA6H;KAC7I,CAAC;SACD,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;SAC7B,KAAK,CAAC,sBAAsB,CAAC;SAC7B,MAAM,CAAC,iBAAiB,CAAC;IAC9B,MAAM,EAAE,SAAS;SACZ,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,iDAAiD;QAC1D,WAAW,EAAE,wGAAwG;KACxH,CAAC;SACD,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;SAC7B,MAAM,CAAC,iBAAiB,CAAC;CACjC,CAAC"}

package/dist/contracts/automations.contract.d.ts

@@ -89,6 +89,8 @@ export declare const automationsContract: {
                 dailyMessageMax: import("zod").ZodOptional<import("zod").ZodNumber>;
                 conversationMessageMax: import("zod").ZodOptional<import("zod").ZodNumber>;
                 sessionTtlMinutes: import("zod").ZodOptional<import("zod").ZodNumber>;
+                aiDisclosure: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                aiDisclosureText: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>>;
             issues: import("zod").ZodOptional<import("zod").ZodObject<{
                 keyFromBrowsers: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -113,7 +115,12 @@ export declare const automationsContract: {
                 fast: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 harness: import("zod").ZodOptional<import("zod").ZodEnum<{
                     "claude-code": "claude-code";
+                    codex: "codex";
+                    muse: "muse";
                     native: "native";
+                    opencode: "opencode";
+                    pi: "pi";
+                    vendor: "vendor";
                 }>>;
             }, import("zod/v4/core").$strip>>>;
             account: import("zod").ZodOptional<import("zod").ZodString>;
@@ -382,6 +389,8 @@ export declare const automationsContract: {
             dailyMessageMax: import("zod").ZodOptional<import("zod").ZodNumber>;
             conversationMessageMax: import("zod").ZodOptional<import("zod").ZodNumber>;
             sessionTtlMinutes: import("zod").ZodOptional<import("zod").ZodNumber>;
+            aiDisclosure: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            aiDisclosureText: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;
         issues: import("zod").ZodOptional<import("zod").ZodObject<{
             keyFromBrowsers: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -406,7 +415,12 @@ export declare const automationsContract: {
             fast: import("zod").ZodOptional<import("zod").ZodBoolean>;
             harness: import("zod").ZodOptional<import("zod").ZodEnum<{
                 "claude-code": "claude-code";
+                codex: "codex";
+                muse: "muse";
                 native: "native";
+                opencode: "opencode";
+                pi: "pi";
+                vendor: "vendor";
             }>>;
         }, import("zod/v4/core").$strip>>>;
         account: import("zod").ZodOptional<import("zod").ZodString>;
@@ -474,6 +488,7 @@ export declare const automationsContract: {
                 automationId: import("zod").ZodString;
                 provider: import("zod").ZodString;
                 channelId: import("zod").ZodOptional<import("zod").ZodString>;
+                threadId: import("zod").ZodOptional<import("zod").ZodString>;
                 author: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>>;
             title: import("zod").ZodOptional<import("zod").ZodString>;

package/dist/contracts/automations.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"automations.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/automations.contract.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,mBAAmB;IAG5B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWJ,KAAK;;;;;;;;;;;;;;;;;;;IAWL,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASP,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASN,UAAU;;;;;;IASV,MAAM;;;;;IASN,WAAW;;;;;IAWX,GAAG;;;;;IAUH,OAAO;;;;;;;;;;;;IAUP,WAAW;;;;;;;;;;;;;;;;;;;;;;IAQX,OAAO;;;;;IASP,MAAM;;;;;CAST,CAAC"}
+{"version":3,"file":"automations.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/automations.contract.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,mBAAmB;IAG5B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWJ,KAAK;;;;;;;;;;;;;;;;;;;IAWL,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASP,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASN,UAAU;;;;;;IASV,MAAM;;;;;IASN,WAAW;;;;;IAWX,GAAG;;;;;IAUH,OAAO;;;;;;;;;;;;IAUP,WAAW;;;;;;;;;;;;;;;;;;;;;;;IAQX,OAAO;;;;;IASP,MAAM;;;;;CAST,CAAC"}

package/dist/contracts/ci.contract.d.ts

@@ -112,7 +112,12 @@ export declare const ciContract: {
             account: import("zod").ZodOptional<import("zod").ZodString>;
             harness: import("zod").ZodOptional<import("zod").ZodEnum<{
                 "claude-code": "claude-code";
+                codex: "codex";
+                muse: "muse";
                 native: "native";
+                opencode: "opencode";
+                pi: "pi";
+                vendor: "vendor";
             }>>;
             effort: import("zod").ZodOptional<import("zod").ZodString>;
             thinking: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -124,7 +129,12 @@ export declare const ciContract: {
             account: import("zod").ZodOptional<import("zod").ZodString>;
             harness: import("zod").ZodOptional<import("zod").ZodEnum<{
                 "claude-code": "claude-code";
+                codex: "codex";
+                muse: "muse";
                 native: "native";
+                opencode: "opencode";
+                pi: "pi";
+                vendor: "vendor";
             }>>;
             effort: import("zod").ZodOptional<import("zod").ZodString>;
             thinking: import("zod").ZodOptional<import("zod").ZodBoolean>;

package/dist/contracts/ci.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ci.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/ci.contract.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,UAAU;IACnB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASJ,KAAK;;;;;;IASL,MAAM;;;;;;IASN,IAAI;;;;;;;;;;;;;;;;;;;;;;;;IASJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUN,CAAC"}
+{"version":3,"file":"ci.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/ci.contract.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,UAAU;IACnB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASJ,KAAK;;;;;;IASL,MAAM;;;;;;IASN,IAAI;;;;;;;;;;;;;;;;;;;;;;;;IASJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUN,CAAC"}

package/dist/contracts/compliance.contract.d.ts

@@ -0,0 +1,163 @@
+export declare const complianceContract: {
+    report: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        generatedAt: import("zod").ZodString;
+        flows: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            group: import("zod").ZodEnum<{
+                analytics: "analytics";
+                connectors: "connectors";
+                maintenance: "maintenance";
+                messaging: "messaging";
+                models: "models";
+                platform: "platform";
+                speech: "speech";
+                web: "web";
+            }>;
+            kind: import("zod").ZodEnum<{
+                browser: "browser";
+                connector: "connector";
+                "email-imap": "email-imap";
+                "email-smtp": "email-smtp";
+                ingress: "ingress";
+                "local-model": "local-model";
+                "model-download": "model-download";
+                "model-endpoint": "model-endpoint";
+                "model-provider": "model-provider";
+                "platform-link": "platform-link";
+                "product-analytics": "product-analytics";
+                "push-notifications": "push-notifications";
+                speech: "speech";
+                "team-chat": "team-chat";
+                "update-check": "update-check";
+                "web-fetch": "web-fetch";
+                "web-search": "web-search";
+                webchat: "webchat";
+            }>;
+            name: import("zod").ZodString;
+            hosts: import("zod").ZodArray<import("zod").ZodString>;
+            operator: import("zod").ZodOptional<import("zod").ZodString>;
+            region: import("zod").ZodOptional<import("zod").ZodString>;
+            thirdCountry: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            active: import("zod").ZodBoolean;
+            personalData: import("zod").ZodEnum<{
+                no: "no";
+                possible: "possible";
+                yes: "yes";
+            }>;
+            shield: import("zod").ZodEnum<{
+                blocked: "blocked";
+                local: "local";
+                masked: "masked";
+                none: "none";
+                trusted: "trusted";
+                watched: "watched";
+            }>;
+            switch: import("zod").ZodOptional<import("zod").ZodString>;
+            question: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        measures: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodEnum<{
+                "action-rules": "action-rules";
+                admission: "admission";
+                "agent-domain": "agent-domain";
+                "ai-notice": "ai-notice";
+                areas: "areas";
+                audit: "audit";
+                "audit-forward": "audit-forward";
+                "audit-reads": "audit-reads";
+                backups: "backups";
+                "command-judge": "command-judge";
+                "credential-gates": "credential-gates";
+                "encryption-at-rest": "encryption-at-rest";
+                "encryption-in-transit": "encryption-in-transit";
+                "guest-jail": "guest-jail";
+                "host-guards": "host-guards";
+                "local-models": "local-models";
+                "member-roles": "member-roles";
+                "privacy-images": "privacy-images";
+                "privacy-names": "privacy-names";
+                "privacy-shield": "privacy-shield";
+                "product-analytics": "product-analytics";
+                retention: "retention";
+                "sign-in": "sign-in";
+                "trusted-providers": "trusted-providers";
+                "webchat-ai-disclosure": "webchat-ai-disclosure";
+            }>;
+            category: import("zod").ZodEnum<{
+                accountability: "accountability";
+                availability: "availability";
+                confidentiality: "confidentiality";
+                integrity: "integrity";
+                minimisation: "minimisation";
+                transparency: "transparency";
+            }>;
+            status: import("zod").ZodEnum<{
+                off: "off";
+                on: "on";
+                partial: "partial";
+                unavailable: "unavailable";
+                unknown: "unknown";
+            }>;
+            facts: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>;
+            preset: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+    document: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        kind: import("zod").ZodEnum<{
+            dpia: "dpia";
+            ropa: "ropa";
+            toms: "toms";
+        }>;
+        language: import("zod").ZodDefault<import("zod").ZodEnum<{
+            en: "en";
+            pl: "pl";
+        }>>;
+        format: import("zod").ZodDefault<import("zod").ZodEnum<{
+            docx: "docx";
+            md: "md";
+        }>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        filename: import("zod").ZodString;
+        mediaType: import("zod").ZodString;
+        encoding: import("zod").ZodEnum<{
+            base64: "base64";
+            utf8: "utf8";
+        }>;
+        content: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+    preset: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            group: import("zod").ZodEnum<{
+                actions: "actions";
+                admission: "admission";
+                analytics: "analytics";
+                audit: "audit";
+                judge: "judge";
+                notice: "notice";
+                privacy: "privacy";
+                retention: "retention";
+            }>;
+            current: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull]>;
+            proposed: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull]>;
+            changes: import("zod").ZodBoolean;
+            available: import("zod").ZodBoolean;
+            owner: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+    applyPreset: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        applied: import("zod").ZodArray<import("zod").ZodString>;
+        skipped: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            reason: import("zod").ZodEnum<{
+                owner: "owner";
+                unavailable: "unavailable";
+                unchanged: "unchanged";
+                unknown: "unknown";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
+};
+//# sourceMappingURL=compliance.contract.d.ts.map

package/dist/contracts/compliance.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compliance.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/compliance.contract.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,kBAAkB;IAC3B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASN,QAAQ;;;;;;;;;;;;;;;;;;;;;;;IAUR,MAAM;;;;;;;;;;;;;;;;;;;;IASN,WAAW;;;;;;;;;;;;;;CAWd,CAAC"}

package/dist/contracts/compliance.contract.js

@@ -0,0 +1,41 @@
+import { procedure } from "../protocol/route-meta.js";
+import { ComplianceDocumentQuerySchema, ComplianceDocumentSchema, ComplianceReportSchema, PresetApplyResultSchema, PresetApplySchema, PresetPreviewSchema, } from "../schemas/compliance.js";
+const maintainerRoute = procedure.meta({ floor: "maintainer", control: "never", panel: false });
+export const complianceContract = {
+    report: maintainerRoute
+        .route({
+        method: "GET",
+        path: "/compliance",
+        summary: "Where data can leave, and what protects it",
+        description: "Every outbound path as configured right now (model providers, mail, team chat, connectors, speech, the web, the platform, updates, analytics), each with its destination, whether personal data can travel on it and whether the privacy shield covers it; and the technical and organisational measures with whether each is in place.",
+    })
+        .output(ComplianceReportSchema),
+    document: maintainerRoute
+        .route({
+        method: "GET",
+        path: "/compliance/document",
+        summary: "A data protection document, filled in from this sandbox",
+        description: "The record of processing activities entry, the data protection impact assessment draft, or the list of technical and organisational measures, in Polish or English, as Markdown or a Word document. What the sandbox knows is filled in; what only the office can say is left as a marked blank.",
+    })
+        .input(ComplianceDocumentQuerySchema)
+        .output(ComplianceDocumentSchema),
+    preset: maintainerRoute
+        .route({
+        method: "GET",
+        path: "/compliance/preset",
+        summary: "What the public-office preset would change",
+        description: "Each stricter setting the preset proposes, with the value this sandbox has now beside it. Reading it changes nothing.",
+    })
+        .output(PresetPreviewSchema),
+    applyPreset: procedure
+        .meta({ floor: "owner", control: "never", panel: false })
+        .route({
+        method: "POST",
+        path: "/compliance/preset",
+        summary: "Apply chosen items of the public-office preset",
+        description: "Applies only the items named, each to its proposed value, and leaves everything else as it is. An item already at its value, or one this sandbox cannot take (a name model that is not installed), is skipped and said so.",
+    })
+        .input(PresetApplySchema)
+        .output(PresetApplyResultSchema),
+};
+//# sourceMappingURL=compliance.contract.js.map

package/dist/contracts/compliance.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compliance.contract.js","sourceRoot":"","sources":["../../src/contracts/compliance.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EACH,6BAA6B,EAC7B,wBAAwB,EACxB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,GACtB,MAAM,0BAA0B,CAAC;AAMlC,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;AAEhG,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAC9B,MAAM,EAAE,eAAe;SAClB,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,aAAa;QACnB,OAAO,EAAE,4CAA4C;QACrD,WAAW,EACP,yUAAyU;KAChV,CAAC;SACD,MAAM,CAAC,sBAAsB,CAAC;IACnC,QAAQ,EAAE,eAAe;SACpB,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,yDAAyD;QAClE,WAAW,EACP,kSAAkS;KACzS,CAAC;SACD,KAAK,CAAC,6BAA6B,CAAC;SACpC,MAAM,CAAC,wBAAwB,CAAC;IACrC,MAAM,EAAE,eAAe;SAClB,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,oBAAoB;QAC1B,OAAO,EAAE,4CAA4C;QACrD,WAAW,EACP,uHAAuH;KAC9H,CAAC;SACD,MAAM,CAAC,mBAAmB,CAAC;IAChC,WAAW,EAAE,SAAS;SACjB,IAAI,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;SACxD,KAAK,CAAC;QACH,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,oBAAoB;QAC1B,OAAO,EAAE,gDAAgD;QACzD,WAAW,EACP,4NAA4N;KACnO,CAAC;SACD,KAAK,CAAC,iBAAiB,CAAC;SACxB,MAAM,CAAC,uBAAuB,CAAC;CACvC,CAAC"}

package/dist/contracts/device.contract.d.ts

@@ -40,6 +40,12 @@ export declare const deviceContract: {
             modified: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         icOverrides: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        intenticOs: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            edition: z.ZodString;
+            version: z.ZodString;
+            channel: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>, Record<never, never>, Record<never, never>>;
     report: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
         machineId: z.ZodOptional<z.ZodString>;

package/dist/contracts/device.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/device.contract.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,cAAc;IAEvB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAER,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIN,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAET,IAAI;;;IAEJ,GAAG;IAEH,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEd,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIZ,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIb,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAId,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKb,YAAY;;;;;;CACf,CAAC"}
+{"version":3,"file":"device.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/device.contract.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,cAAc;IAEvB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAER,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIN,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAET,IAAI;;;IAEJ,GAAG;IAEH,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEd,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIZ,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIb,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAId,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKb,YAAY;;;;;;CACf,CAAC"}

package/dist/contracts/extensions.contract.d.ts

@@ -40,6 +40,7 @@ export declare const extensionsContract: {
                             cron: import("zod").ZodOptional<import("zod").ZodString>;
                             provider: import("zod").ZodOptional<import("zod").ZodString>;
                             eventType: import("zod").ZodOptional<import("zod").ZodString>;
+                            mentioned: import("zod").ZodOptional<import("zod").ZodBoolean>;
                             event: import("zod").ZodOptional<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                         guard: import("zod").ZodOptional<import("zod").ZodString>;
@@ -581,6 +582,7 @@ export declare const extensionsContract: {
                             cron: import("zod").ZodOptional<import("zod").ZodString>;
                             provider: import("zod").ZodOptional<import("zod").ZodString>;
                             eventType: import("zod").ZodOptional<import("zod").ZodString>;
+                            mentioned: import("zod").ZodOptional<import("zod").ZodBoolean>;
                             event: import("zod").ZodOptional<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                         guard: import("zod").ZodOptional<import("zod").ZodString>;

package/dist/contracts/extensions.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extensions.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/extensions.contract.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,kBAAkB;IAC3B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUJ,MAAM;;;;;;;IAYN,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUX,MAAM;;;;;;;IAUN,QAAQ;;;;;;IASR,WAAW;;;;;;IAYX,OAAO;;;;;;IAYP,UAAU;;;;;;IAWV,WAAW;;;;;IAUX,SAAS;;;;;;;;;;;;;;IAYT,YAAY;;;;IASZ,aAAa;;;;;;;;;;;;;;;IAUb,WAAW;;;;;;;;IAUX,MAAM;;;;;;;IASN,eAAe;;;;;;;;;;;;;;IAWf,aAAa;;;;;;;;;;;IASb,YAAY;;;;;;IASZ,WAAW;;;;;;IAWX,OAAO;;;;;;;;;;;;;;;;;;IASP,MAAM;;;;;;;;;;;;;;IAUN,QAAQ;;;;;;;IASR,SAAS;;;;;;;;;;;;;CAUZ,CAAC"}
+{"version":3,"file":"extensions.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/extensions.contract.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,kBAAkB;IAC3B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUJ,MAAM;;;;;;;IAYN,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUX,MAAM;;;;;;;IAUN,QAAQ;;;;;;IASR,WAAW;;;;;;IAYX,OAAO;;;;;;IAYP,UAAU;;;;;;IAWV,WAAW;;;;;IAUX,SAAS;;;;;;;;;;;;;;IAYT,YAAY;;;;IASZ,aAAa;;;;;;;;;;;;;;;IAUb,WAAW;;;;;;;;IAUX,MAAM;;;;;;;IASN,eAAe;;;;;;;;;;;;;;IAWf,aAAa;;;;;;;;;;;IASb,YAAY;;;;;;IASZ,WAAW;;;;;;IAWX,OAAO;;;;;;;;;;;;;;;;;;IASP,MAAM;;;;;;;;;;;;;;IAUN,QAAQ;;;;;;;IASR,SAAS;;;;;;;;;;;;;CAUZ,CAAC"}

package/dist/contracts/loops.contract.d.ts

@@ -41,7 +41,12 @@ export declare const loopsContract: {
             agent: import("zod").ZodOptional<import("zod").ZodString>;
             harness: import("zod").ZodOptional<import("zod").ZodEnum<{
                 "claude-code": "claude-code";
+                codex: "codex";
+                muse: "muse";
                 native: "native";
+                opencode: "opencode";
+                pi: "pi";
+                vendor: "vendor";
             }>>;
             account: import("zod").ZodOptional<import("zod").ZodString>;
             model: import("zod").ZodOptional<import("zod").ZodString>;
@@ -121,7 +126,12 @@ export declare const loopsContract: {
         agent: import("zod").ZodOptional<import("zod").ZodString>;
         harness: import("zod").ZodOptional<import("zod").ZodEnum<{
             "claude-code": "claude-code";
+            codex: "codex";
+            muse: "muse";
             native: "native";
+            opencode: "opencode";
+            pi: "pi";
+            vendor: "vendor";
         }>>;
         account: import("zod").ZodOptional<import("zod").ZodString>;
         model: import("zod").ZodOptional<import("zod").ZodString>;
@@ -172,7 +182,12 @@ export declare const loopsContract: {
         agent: import("zod").ZodOptional<import("zod").ZodString>;
         harness: import("zod").ZodOptional<import("zod").ZodEnum<{
             "claude-code": "claude-code";
+            codex: "codex";
+            muse: "muse";
             native: "native";
+            opencode: "opencode";
+            pi: "pi";
+            vendor: "vendor";
         }>>;
         account: import("zod").ZodOptional<import("zod").ZodString>;
         model: import("zod").ZodOptional<import("zod").ZodString>;

package/dist/contracts/loops.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loops.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/loops.contract.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,aAAa;IAEtB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUJ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWL,IAAI;;;;;IAYJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWV,YAAY;;;;;CAUf,CAAC"}
+{"version":3,"file":"loops.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/loops.contract.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,aAAa;IAEtB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUJ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWL,IAAI;;;;;IAYJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWV,YAAY;;;;;CAUf,CAAC"}