@intentic/sandbox-contract 1.337.0 → 1.339.0

package/src/schemas/links.ts

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { AskQuestionSchema } from "../events/requests.js";
+import { entryId } from "./internal.js";
+
+// LINKED SANDBOXES: one of the owner's sandboxes handing tasks to another. The sandbox that hands work over holds a
+// `link` capability card (schemas/capabilities.ts LinkConfigSchema); the one that takes it holds an inbound link, minted
+// by its owner, whose token is that card's credential. Everything the taking side does with a task is decided there, by
+// the terms on its own link: which persona the work wears, whether each task waits for its owner, how many turns an hour.
+// The handing side only asks, reads and stops.
+
+// What a link token looks like: issuer-prefixed like a control token (`ict_`), and never the same credential.
+export const LINK_TOKEN_PREFIX = "ilk_";
+// The header the taking sandbox's link doors read it from.
+export const LINK_HEADER = "x-intentic-link";
+// How many links a task may have crossed before the one it is asking across. A task a person started is at 0; a sandbox
+// that took a task through a link and hands part of it on asks at 1. Past this the asking sandbox refuses before it
+// calls, and the taking sandbox refuses again, so two sandboxes cannot hand one task back and forth for ever.
+export const LINK_MAX_HOPS = 2;
+// The ceiling a link's own hourly allowance may be set to, and what one is minted with when its owner names none.
+export const LINK_TURNS_PER_HOUR_MAX = 120;
+export const LINK_TURNS_PER_HOUR_DEFAULT = 20;
+
+// THE TERMS, set on the taking side and enforced there: what the asking side is told, never what it decides.
+export const LinkTermsSchema = z.object({
+    actsAs: entryId
+        .optional()
+        .describe(
+            "The persona every task through this link wears: its accounts, its shelves, its folders, its model. Absent, the task runs with no signed-in account and the full toolbox, as any unattended wake does.",
+        ),
+    approve: z
+        .boolean()
+        .default(false)
+        .describe("Each new task waits for this sandbox's owner to allow it before anything runs. Follow-up messages to a task already allowed do not."),
+    turnsPerHour: z
+        .number()
+        .int()
+        .min(1)
+        .max(LINK_TURNS_PER_HOUR_MAX)
+        .default(LINK_TURNS_PER_HOUR_DEFAULT)
+        .describe("How many turns the link may start in an hour, new tasks and follow-ups alike. Words said into a turn already running are not counted."),
+});
+export type LinkTerms = z.infer<typeof LinkTermsSchema>;
+
+// Where the link's holder says it is, as the owner's editor named it at pairing; informational, never a credential.
+export const LinkPeerSchema = z.object({
+    sandboxId: z.string().max(100).optional().describe("The asking sandbox's id on the owner's account."),
+    url: z.string().max(500).optional().describe("The asking sandbox's own address."),
+});
+export type LinkPeer = z.infer<typeof LinkPeerSchema>;
+
+// A task waiting for the taking sandbox's owner, when the link's terms say every task waits.
+export const LinkRequestSchema = z.object({
+    id: z.string().describe("The task's own id, the one the asking sandbox gave it."),
+    conversationId: z.string().describe("The conversation the task opens here once it is allowed."),
+    task: z.string().describe("What it asks, cut to a readable length."),
+    title: z.string().optional().describe("Its one-line name."),
+    askedAt: z.number().describe("When it arrived, in epoch milliseconds."),
+});
+export type LinkRequest = z.infer<typeof LinkRequestSchema>;
+
+// One inbound link as the owner's Access page lists it: everything but the token, which is kept only as a hash.
+export const InboundLinkSummarySchema = z.object({
+    id: z.string(),
+    label: z.string().describe("What the asking sandbox is called here: its name at pairing, or what the owner typed."),
+    from: LinkPeerSchema.optional(),
+    terms: LinkTermsSchema,
+    createdAt: z.number(),
+    createdBy: z.string().optional().describe("The owner who minted it."),
+    lastUsedAt: z.number().optional().describe("The last time it was used, coarse on purpose; absent means never."),
+    conversations: z.number().int().nonnegative().describe("How many conversations it has opened here."),
+    requests: z.array(LinkRequestSchema).describe("Tasks waiting for the owner's yes, oldest first."),
+});
+export type InboundLinkSummary = z.infer<typeof InboundLinkSummarySchema>;
+export const InboundLinksListSchema = z.object({ links: z.array(InboundLinkSummarySchema) });
+export type InboundLinksList = z.infer<typeof InboundLinksListSchema>;
+
+// POST /system/links: what the owner (or their editor, pairing two of their sandboxes) mints a link with.
+export const InboundLinkMintSchema = z.object({
+    label: z.string().trim().min(1).max(60),
+    from: LinkPeerSchema.optional(),
+    terms: LinkTermsSchema.partial().optional(),
+});
+export type InboundLinkMint = z.infer<typeof InboundLinkMintSchema>;
+// The raw token, shown exactly once.
+export const InboundLinkMintedSchema = z.object({ id: z.string(), token: z.string() });
+export type InboundLinkMinted = z.infer<typeof InboundLinkMintedSchema>;
+// POST /system/links/{id}: new terms, whole fields replaced, the rest kept.
+export const InboundLinkTermsUpdateSchema = LinkTermsSchema.partial().extend({ label: z.string().trim().min(1).max(60).optional() });
+export type InboundLinkTermsUpdate = z.infer<typeof InboundLinkTermsUpdateSchema>;
+// POST /system/links/{id}/requests/{request}: the owner's answer to one waiting task.
+export const LinkRequestDecisionSchema = z.object({ approve: z.boolean() });
+export type LinkRequestDecision = z.infer<typeof LinkRequestDecisionSchema>;
+
+/* THE LINK DOORS, called by the asking sandbox's daemon with the link token, never by a browser. */
+
+// GET /link: the link still works, and what it is held to.
+export const LinkHelloSchema = z.object({
+    sandbox: z.string().describe("What the taking sandbox calls itself."),
+    link: z.object({ id: z.string(), label: z.string() }),
+    terms: z.object({
+        approve: z.boolean(),
+        turnsPerHour: z.number().int(),
+        persona: z.string().optional().describe("The name of the persona its tasks wear, when they wear one."),
+    }),
+    maxHops: z.number().int(),
+});
+export type LinkHello = z.infer<typeof LinkHelloSchema>;
+
+// POST /link/conversations: one task, opening one conversation. `requestId` is the asking side's own id for it: asking
+// again under the same id answers with what became of the first ask, so a lost answer never opens a second conversation.
+export const LinkTaskSchema = z.object({
+    requestId: z
+        .string()
+        .min(1)
+        .max(100)
+        .regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/),
+    task: z.string().min(1).max(60_000).describe("The whole task, self-contained: the taking agent sees nothing else."),
+    title: z.string().max(80).optional().describe("A one-line name for the conversation it opens."),
+    hops: z.number().int().min(0).max(10).default(0).describe("How many links the task already crossed before this one."),
+    tainted: z
+        .string()
+        .max(500)
+        .optional()
+        .describe("What outside content the asking turn had taken in, when it had: the taking turn carries it on."),
+    from: z
+        .object({
+            conversation: z.string().max(100).optional(),
+            title: z.string().max(200).optional(),
+        })
+        .optional()
+        .describe("The asking conversation, for the taking sandbox's own record."),
+});
+export type LinkTask = z.infer<typeof LinkTaskSchema>;
+
+// Where a linked task stands, as the asking side reads it.
+// held: waiting for the taking sandbox's owner to allow it. running: a turn is working on it. blocked: parked on a card;
+// `question` carries one the asking agent may answer, anything else waits for the taking sandbox's owner. finished: its
+// last turn ended, `report` is what it said. failed: its last turn failed. declined: the owner said no. stopped: the
+// asking side stopped it, or its owner did.
+export const LinkTaskStateSchema = z.enum(["held", "running", "blocked", "finished", "failed", "declined", "stopped"]);
+export type LinkTaskState = z.infer<typeof LinkTaskStateSchema>;
+
+export const LinkQuestionSchema = z.object({
+    requestId: z.string(),
+    questions: z.array(AskQuestionSchema),
+});
+export type LinkQuestion = z.infer<typeof LinkQuestionSchema>;
+
+export const LinkTaskStatusSchema = z.object({
+    conversationId: z.string(),
+    state: LinkTaskStateSchema,
+    title: z.string().optional(),
+    report: z.string().optional().describe("The last settled turn's closing message, whole."),
+    question: LinkQuestionSchema.optional(),
+    waitingOn: z.string().optional().describe("What a blocked task waits on when it is not a question the asking agent may answer."),
+    error: z.string().optional(),
+    // Moves every time anything above changes, so a long poll can wait for a version it has not seen.
+    version: z.number().int().nonnegative(),
+    updatedAt: z.number(),
+});
+export type LinkTaskStatus = z.infer<typeof LinkTaskStatusSchema>;
+
+// POST /link/conversations/{id}/messages: follow-up words, said into the running turn or opening the next one.
+export const LinkMessageSchema = z.object({
+    message: z.string().min(1).max(60_000),
+    messageId: z.string().min(1).max(128).optional(),
+    tainted: z.string().max(500).optional(),
+});
+export type LinkMessage = z.infer<typeof LinkMessageSchema>;
+export const LinkMessageReceiptSchema = z.object({
+    delivered: z.enum(["started", "steered", "queued"]),
+});
+export type LinkMessageReceipt = z.infer<typeof LinkMessageReceiptSchema>;
+
+// POST /link/conversations/{id}/answer: picks for the question the task is parked on, and only a question.
+export const LinkAnswerSchema = z.object({
+    requestId: z.string().min(1),
+    answers: z.record(z.string(), z.array(z.string())),
+});
+export type LinkAnswer = z.infer<typeof LinkAnswerSchema>;

package/src/schemas/maintenance.ts

@@ -341,6 +341,7 @@ export const ChoreProbeRequestSchema = z.object({
 });
 // POST /chores/ledger: record a run, or snooze. Daemon-written so a turn started from anywhere (panel, automation,
 // agent) lands in one ledger.
+/** @alias */
 export const ChoreLedgerWriteSchema = ChoreLedgerEntrySchema;
 // `warn` is a real third state, not a soft failure: reporting "pass" when nothing has been exercised yet would be the
 // check lying.

package/src/schemas/members.ts

@@ -30,6 +30,10 @@ export const REACHABLE_CREDENTIAL_KINDS: readonly CapabilityKind[] = [
     "webext",
     "plugin",
     "extension",
+    // The owner's account: a person this sandbox works for may be kept from making sandboxes on it.
+    "fleet",
+    // Another of the owner's sandboxes: a person may be kept from handing it work.
+    "link",
 ];
 
 // WHAT ONE PERSON MAY DO, as three independent answers rather than one rung of a ladder: whether their conversations

package/src/schemas/needs.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { KeyringShareModeSchema } from "./keyring.js";
 import { AutomationSchema } from "./automations.js";
 
 // A need: something an agent cannot finish its task without that only a person can provide (a connection, a secret's
@@ -29,8 +30,10 @@ export const isOpenNeed = (need: { readonly status: NeedStatus }): boolean => OP
 const FieldValuesSchema = z.record(z.string(), z.string());
 
 export const CapabilityNeedModeSchema = z
-    .enum(["connect", "reconnect", "change"])
-    .describe("Connect something new, give a connected one a credential that works again, or change a setting on a connected one.");
+    .enum(["connect", "reconnect", "change", "remove"])
+    .describe(
+        "Connect something new, give a connected one a credential that works again, change a setting on a connected one, or remove a connected one.",
+    );
 export type CapabilityNeedMode = z.infer<typeof CapabilityNeedModeSchema>;
 
 export const CapabilityNeedSchema = z.object({
@@ -38,7 +41,7 @@ export const CapabilityNeedSchema = z.object({
     entry: z.string().min(1).describe("The catalog entry, as the catalog names it."),
     name: z.string().describe("What the catalog calls it, never the agent's spelling."),
     mode: CapabilityNeedModeSchema,
-    instance: z.string().optional().describe("The connection a reconnect or a change is about."),
+    instance: z.string().optional().describe("The connection a reconnect, a change or a removal is about."),
     target: z.string().optional().describe("The site, host or address the connection is for, when the entry can hold several."),
     prefill: FieldValuesSchema.optional().describe(
         "Settings the agent could fill in for a new connection, never a credential: the daemon keeps only the entry's own non-secret fields.",
@@ -192,6 +195,10 @@ export const NeedAskSchema = z.discriminatedUnion("kind", [
             .boolean()
             .optional()
             .describe("It is connected, but its credential is being refused: ask for a new one rather than being told to use it."),
+        remove: z
+            .boolean()
+            .optional()
+            .describe("Take a connection away: the person removes it in one press on the card, as the Capabilities page's Remove does."),
     }),
     SecretNeedSchema,
     z.object({
@@ -239,7 +246,7 @@ export const NeedAnswerSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("decline"), note: z.string().max(500).optional().describe("Why not, passed to the agent.") }),
     // A connection's yes before its form is saved: moves the need to working, so the board keeps saying so.
     z.object({ kind: z.literal("accept") }),
-    // A change to a connected capability's settings, applied as the card showed it.
+    // A change to a connected capability's settings, or its removal, applied as the card showed it.
     z.object({ kind: z.literal("apply") }),
     z.object({ kind: z.literal("grant"), scope: GrantScopeSchema }),
     z.object({ kind: z.literal("release") }),
@@ -251,6 +258,15 @@ export const NeedIdParamSchema = z.object({ id: z.string().min(1).describe("Whic
 export const NeedAnswerInputSchema = NeedIdParamSchema.extend({ answer: NeedAnswerSchema });
 export const NeedSecretInputSchema = NeedIdParamSchema.extend({
     value: z.string().min(1).max(64_000).describe("The secret's value. Stored, never echoed, never written into a transcript."),
+    // "Keep it on my computer": the value is sealed to that computer's keyring inbox (schemas/keyring.ts) and kept there,
+    // and this sandbox holds a pointer to it; nothing is stored here. Absent: stored in the sandbox, as before.
+    keepOn: z
+        .object({
+            device: z.string().min(1).describe("Which computer's keyring keeps it, by its device card."),
+            mode: KeyringShareModeSchema.describe("How that keyring answers this sandbox for it."),
+        })
+        .optional()
+        .describe("Keep it in the keyring on one of your computers instead of in the sandbox."),
 });
 export const NeedsQuerySchema = z.object({
     conversationId: z.string().optional().describe("One conversation's needs. Absent is every conversation's."),
@@ -355,7 +371,7 @@ export const OwnerGrantSchema = z.discriminatedUnion("kind", [
         hooks: z.array(z.string()).describe("Each hook in the set in the daemon's words: when it runs and what it runs."),
         at: z.number().describe("When it was approved, in milliseconds."),
     }),
-    // A workspace extension approved for the powers it declared then (extensions/extension-approvals.ts).
+    // A workspace extension approved for the powers it declared then (capabilities/extension-inventory/extension-approvals.ts).
     z.object({
         kind: z.literal("extension"),
         id: z.string().describe("The extension, by its publisher.name id."),

package/src/schemas/organisation.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { PRESET_GROUPS, type PresetGroup, PresetGroupSchema } from "./compliance.js";
+
+// An ORGANISATION'S POLICY as a sandbox holds it (docs/architecture/organisations.md). A sandbox that belongs to an
+// organisation is handed this by the platform it is registered with; a personal sandbox never holds one, and nothing
+// here applies to it. The daemon is the enforcing copy: a section the policy locks is refused at the daemon's own
+// middleware for every caller, the owner and the agent included, and the editor only draws what the daemon says.
+
+// The parts of a sandbox an organisation can take out of its members' hands. Each is a section of the editor's sandbox
+// hub (sandboxNav.ts) except `updates`, which is the auto-update switch on Overview. Which daemon routes each one
+// covers is policy/org-locks.ts, beside the refusal that reads it.
+export const ORG_SECTIONS = [
+    "models",
+    "agent",
+    "environment",
+    "secrets",
+    "data-protection",
+    "extensions",
+    "access",
+    "areas",
+    "personas",
+    "updates",
+] as const;
+export const OrgSectionSchema = z.enum(ORG_SECTIONS);
+export type OrgSection = z.infer<typeof OrgSectionSchema>;
+
+// `open`: as in a personal sandbox. `locked`: readable, every change refused. `hidden`: locked, and the editor does not
+// show the section at all. Hidden is a fence on what people are shown, not on what the sandbox reads: the agent still
+// uses the secrets of a hidden Secrets section, and a read route answers as it always did.
+export const OrgSectionModeSchema = z.enum(["open", "locked", "hidden"]);
+export type OrgSectionMode = z.infer<typeof OrgSectionModeSchema>;
+
+// What an organisation admin edits. A section left out is open, so a policy written before a section existed opens it
+// rather than guessing.
+//
+// `preset` PINS settings rather than locking a page: each named group of the public-office preset (compliance.ts
+// PRESET_GROUPS; which settings a group holds is the daemon's compliance/preset.ts) is applied to what the sandbox READS,
+// whatever its files say, and a change that would undo it is refused. Strings on the wire, not the enum: a group a newer
+// platform names and this daemon does not know is skipped and reported (`unenforced`), never a reason to refuse the
+// whole policy, which would stop every later edition reaching an older daemon. The platform validates the names an
+// admin saves.
+//
+// `membersOnly` makes the organisation's member list the outer fence of every bound sandbox's roster: a person the
+// organisation removes is taken off each sandbox's roster by its daemon at the next fetch, and a grant to someone who
+// is not a member is refused. The sandbox's owner is not on a roster, so this never reaches them.
+//
+// Both are optional rather than defaulted, so every policy written before them (a stored row, a held file, a literal)
+// still reads as the same type: absent is no pin and an open roster.
+export const OrgPolicyRulesSchema = z.object({
+    sections: z
+        .partialRecord(OrgSectionSchema, OrgSectionModeSchema)
+        .default({})
+        .describe("How each section is held. A section left out is open."),
+    preset: z
+        .array(z.string().min(1).max(40))
+        .max(40)
+        .optional()
+        .describe(`Public-office preset groups every bound sandbox is held to (${PRESET_GROUPS.join(", ")}). Unknown names are skipped.`),
+    membersOnly: z
+        .boolean()
+        .optional()
+        .describe("Only the organisation's members may be on a bound sandbox's roster; removing someone from the organisation removes them everywhere."),
+});
+export type OrgPolicyRules = z.infer<typeof OrgPolicyRulesSchema>;
+
+// The rules as one sandbox receives them: whose they are and which edition. `version` only grows on the platform; the
+// daemon reports the edition it holds back, which is how the organisation's console tells applied from pending.
+// `people` is computed by the platform, never edited: the organisation's members, each as the sha256 of
+// orgPersonPreimage, sent only while `membersOnly` is on, so a daemon can test an address without being handed the
+// staff list in clear. A policy with `membersOnly` and no `people` fences nothing: no list is not an empty list.
+export const OrgPolicySchema = OrgPolicyRulesSchema.extend({
+    orgId: z.string().min(1).max(64),
+    orgName: z.string().min(1).max(120),
+    version: z.number().int().min(1),
+    people: z.array(z.string().regex(/^[0-9a-f]{64}$/u)).max(10_000).optional(),
+});
+export type OrgPolicy = z.infer<typeof OrgPolicySchema>;
+
+// What the daemon answers the editor about it (GET /org/policy): unbound, or bound with the policy it enforces and
+// when it last heard from the platform about it. `provisional` is a held file that could not be read: every section is
+// held read-only until the platform answers, since a bound sandbox must not open up because its record broke.
+// `unenforced` names preset groups the policy pins that this daemon does not know.
+export const OrgPolicyStateSchema = z.discriminatedUnion("bound", [
+    z.object({ bound: z.literal(false) }),
+    z.object({
+        bound: z.literal(true),
+        policy: OrgPolicySchema,
+        receivedAt: z.string().describe("When this edition arrived (ISO)."),
+        provisional: z.boolean().optional(),
+        unenforced: z.array(z.string()).optional(),
+    }),
+]);
+export type OrgPolicyState = z.infer<typeof OrgPolicyStateSchema>;
+
+// How a policy holds one section; anything it does not name is open.
+export const orgSectionMode = (policy: Pick<OrgPolicy, "sections"> | undefined, section: OrgSection): OrgSectionMode =>
+    policy?.sections[section] ?? "open";
+
+// The preset groups a policy pins that this build knows, in the contract's order; none for a personal sandbox. A policy
+// stored before pins existed has no `preset` at all.
+export const orgPinnedGroups = (policy: Partial<Pick<OrgPolicy, "preset">> | undefined): PresetGroup[] =>
+    PRESET_GROUPS.filter((group) => policy?.preset?.includes(group) === true);
+
+// The names a policy pins that this build does not know.
+export const orgUnknownPins = (policy: Partial<Pick<OrgPolicy, "preset">> | undefined): string[] =>
+    (policy?.preset ?? []).filter((name) => !PresetGroupSchema.safeParse(name).success);
+
+// What both sides hash (sha256, hex) to name one member of one organisation in `people`: salted with the organisation's
+// id, so the same address in two organisations does not read as the same digest.
+export const orgPersonPreimage = (orgId: string, email: string): string => `intentic-org-person:${orgId}:${email.trim().toLowerCase()}`;

package/src/schemas/phone.ts

@@ -62,6 +62,9 @@ export const PhoneFactsSchema = z.object({
     sdk: z.number().int(),
     // "direct" (downloaded from intentic.dev, can touch and type) or "play" (the store build, which cannot).
     build: z.string(),
+    // What kind of Android device answered: "watch" for Wear OS, which has no folders and no notification access to
+    // give; absent from an app older than this field, which is a phone. A string, so a newer app's "tablet" still reads.
+    form: z.string().optional(),
     // The pause tile on the phone; true means every tool refuses and says the person paused it.
     paused: z.boolean(),
     // What the person has switched on in Android's own settings for this app.

package/src/schemas/privacy.test.ts

@@ -0,0 +1,63 @@
+import { DEFAULT_PRIVACY_SHIELD, PRIVACY_PATTERN_MAX, PrivacyShieldPolicySchema, patternProblem } from "./privacy.js";
+
+// The owner's own patterns run on every string bound for an untrusted provider, in the daemon's one thread: one that
+// cannot compile, matches empty text or nests a repeat inside a repeat is refused before it is saved.
+
+describe(`patternProblem`, () => {
+    it(`takes the patterns an ID or a customer number is written with`, () => {
+        for (const pattern of [
+            String.raw`EMP-\d{6}`,
+            String.raw`\b[A-Z]{3}\d{6}\b`,
+            String.raw`Customer:\s*(?<value>\d+)`,
+            String.raw`(?:\d{3}-){2}\d{4}`,
+            String.raw`[A-Z]{2}\d{2}(?:[ -]?\d{4}){3}`,
+            String.raw`(?<=Ref\. )[A-Z0-9]+`,
+            String.raw`(ab|cd)+`,
+            String.raw`[(+*)]+x`,
+        ]) {
+            expect([pattern, patternProblem(pattern)]).toEqual([pattern, undefined]);
+        }
+    });
+
+    it(`refuses one that does not compile, matches empty text or is too long`, () => {
+        expect(patternProblem(`(unclosed`)).toBe(`invalid`);
+        expect(patternProblem(String.raw`\p{Nope}`)).toBe(`invalid`);
+        expect(patternProblem(String.raw`\d*`)).toBe(`empty`);
+        expect(patternProblem(`a|`)).toBe(`empty`);
+        expect(patternProblem(` `)).toBe(`empty`);
+        expect(patternProblem(`a`.repeat(PRIVACY_PATTERN_MAX + 1))).toBe(`tooLong`);
+    });
+
+    it(`refuses a variable repeat inside a variable repeat, the shape that backtracks for minutes`, () => {
+        expect(patternProblem(`(a+)+b`)).toBe(`nested`);
+        expect(patternProblem(String.raw`(\w+\s?)*!`)).toBe(`nested`);
+        expect(patternProblem(String.raw`(?:x(?:\d{2,})?)+y`)).toBe(`nested`);
+        expect(patternProblem(String.raw`(?<id>\d+-?){2,}z`)).toBe(`nested`);
+        // A fixed count is no variable repeat, inside or out.
+        expect(patternProblem(String.raw`(\d{3}-?){3}`)).toBeUndefined();
+        expect(patternProblem(String.raw`(\d{3}){2,}`)).toBeUndefined();
+    });
+});
+
+describe(`PrivacyShieldPolicySchema`, () => {
+    it(`reads a policy written before the owner's lists and rules as having none`, () => {
+        expect(PrivacyShieldPolicySchema.parse({ mode: `on` })).toMatchObject({ dictionary: { off: [], lists: [] }, rules: [] });
+        expect(DEFAULT_PRIVACY_SHIELD.rules).toEqual([]);
+    });
+
+    it(`fills a rule's defaults and keeps a stored pattern whatever a later build judges of it`, () => {
+        const parsed = PrivacyShieldPolicySchema.parse({
+            rules: [{ id: `r1`, title: `Nested`, class: `identity-document`, match: `pattern`, pattern: `(a+)+` }],
+        });
+        expect(parsed.rules[0]).toEqual({
+            id: `r1`,
+            title: `Nested`,
+            on: true,
+            class: `identity-document`,
+            match: `pattern`,
+            terms: [],
+            pattern: `(a+)+`,
+            matchCase: false,
+        });
+    });
+});