@botiverse/porthole 0.14.5 → 0.14.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (76) hide show
  1. package/CHANGELOG.md +66 -0
  2. package/dist/check/page-source.js +1 -1
  3. package/dist/check/page.js +5 -1
  4. package/dist/compile/policy.d.ts +6 -0
  5. package/dist/compile/policy.js +6 -0
  6. package/dist/conformance/entry.d.ts +25 -6
  7. package/dist/conformance/entry.js +69 -18
  8. package/dist/conformance/harness/page.d.ts +12 -0
  9. package/dist/conformance/harness/page.js +95 -51
  10. package/dist/conformance/harness-source.js +1 -1
  11. package/dist/conformance/host-kit.js +39 -13
  12. package/dist/conformance/served.js +148 -0
  13. package/dist/files/paths.d.ts +2 -2
  14. package/dist/files/paths.js +12 -2
  15. package/dist/host/client.d.ts +8 -0
  16. package/dist/host/client.js +47 -17
  17. package/dist/host/create-host.d.ts +10 -0
  18. package/dist/host/create-host.js +124 -10
  19. package/dist/host/door.d.ts +41 -0
  20. package/dist/host/door.js +55 -0
  21. package/dist/host/locate.js +2 -0
  22. package/dist/host/locator.d.ts +55 -3
  23. package/dist/host/locator.js +152 -42
  24. package/dist/host/outcome.d.ts +54 -1
  25. package/dist/host/outcome.js +33 -8
  26. package/dist/host/types.d.ts +10 -2
  27. package/dist/isolation/served.d.ts +1 -1
  28. package/dist/isolation/served.js +35 -0
  29. package/dist/isolation/types.d.ts +20 -2
  30. package/dist/isolation/types.js +2 -0
  31. package/dist/platform/types.d.ts +22 -0
  32. package/dist/platform/web.js +55 -12
  33. package/dist/react/view.d.ts +13 -0
  34. package/dist/react/view.js +101 -2
  35. package/dist/server/files.d.ts +11 -0
  36. package/dist/server/files.js +26 -4
  37. package/dist/server/host.js +106 -28
  38. package/dist/server/index.d.ts +2 -1
  39. package/dist/server/index.js +7 -1
  40. package/dist/server/pages.d.ts +32 -0
  41. package/dist/server/pages.js +82 -6
  42. package/dist/server/server.js +194 -16
  43. package/dist/server/types.d.ts +38 -1
  44. package/dist/transport/post-message.d.ts +1 -9
  45. package/dist/transport/post-message.js +2 -8
  46. package/docs/ADOPTING.md +73 -4
  47. package/docs/DECISIONS.md +245 -0
  48. package/docs/DESIGN.md +24 -18
  49. package/docs/THREAT_MODEL.md +79 -13
  50. package/package.json +1 -1
  51. package/src/check/page.ts +6 -1
  52. package/src/compile/policy.ts +7 -0
  53. package/src/conformance/entry.ts +129 -24
  54. package/src/conformance/harness/page.ts +112 -49
  55. package/src/conformance/host-kit.ts +53 -16
  56. package/src/conformance/served.ts +184 -0
  57. package/src/files/paths.ts +11 -2
  58. package/src/host/client.ts +59 -22
  59. package/src/host/create-host.ts +144 -18
  60. package/src/host/door.ts +97 -0
  61. package/src/host/locate.ts +2 -0
  62. package/src/host/locator.ts +208 -57
  63. package/src/host/outcome.ts +41 -9
  64. package/src/host/types.ts +10 -2
  65. package/src/isolation/served.ts +40 -1
  66. package/src/isolation/types.ts +19 -2
  67. package/src/platform/types.ts +21 -0
  68. package/src/platform/web.ts +55 -20
  69. package/src/react/view.tsx +149 -2
  70. package/src/server/files.ts +37 -5
  71. package/src/server/host.ts +131 -46
  72. package/src/server/index.ts +7 -1
  73. package/src/server/pages.ts +101 -6
  74. package/src/server/server.ts +266 -32
  75. package/src/server/types.ts +41 -1
  76. package/src/transport/post-message.ts +1 -9
@@ -3,10 +3,13 @@ import type { FrameOutcome } from "../host/types.ts";
3
3
  import type { ConformanceTest } from "./probes.ts";
4
4
 
5
5
  /**
6
- * Redirect entry's cases (P068): a clean address opens directly, signed in or not, and never
7
- * shows content without access; its one-time code works once, on its own origin; in a frame, the
8
- * app's sign-in never shows. A host implements `EntryConformanceHost` (or gives
9
- * `defineHostConformance` its `entry`).
6
+ * Redirect entry's cases (P068, P125): a clean address opens directly in a tab, signed in or not,
7
+ * and never shows content without access; its one-time code works once, on its own origin. A clean
8
+ * address is for a tab: a host frames what one names by resolving it through its issue endpoint
9
+ * first (a door, a ticket), and signed out, denied or not found, it builds no frame at all and
10
+ * shows its fallback from that answer. A clean address framed as it is goes nowhere: the host
11
+ * refuses it (no door), and the content origin answers it with a page that says nothing. A host
12
+ * implements `EntryConformanceHost` (or gives `defineHostConformance` its `entry`).
10
13
  */
11
14
 
12
15
  export interface EntryConformanceHost {
@@ -37,13 +40,32 @@ export interface EntryConformanceHost {
37
40
  */
38
41
  completeSignIn?(page: Page): Promise<void>;
39
42
  /**
40
- * Frames a clean address on the app's page as the app would (a location of that address),
41
- * returning the frame and the display's outcome once it has one.
43
+ * Shows a clean address on the app's page as the app would (P125): resolved through the app's
44
+ * issue endpoint (`client.resolve`, `<PortholeView address>`), then framed through the location
45
+ * it issued. Returns the frame, the display's outcome once it has one, and whether any frame was
46
+ * ever made for it.
42
47
  */
43
48
  frame(
44
49
  page: Page,
45
50
  url: string,
46
- ): Promise<{ frame(): Promise<Frame>; outcome(): Promise<FrameOutcome> }>;
51
+ ): Promise<{
52
+ frame(): Promise<Frame>;
53
+ outcome(): Promise<FrameOutcome>;
54
+ framed(): Promise<boolean>;
55
+ }>;
56
+ /**
57
+ * Gives the app's `createHost` a clean address as a frame's location, as it is (no issue, no
58
+ * door), as a host of the wrong kind would. Returns the outcome, whether a frame was made, and
59
+ * the host errors it heard.
60
+ */
61
+ frameDirectly(
62
+ page: Page,
63
+ url: string,
64
+ ): Promise<{
65
+ outcome(): Promise<FrameOutcome>;
66
+ framed(): Promise<boolean>;
67
+ hostErrors(): Promise<readonly { readonly message: string; readonly kind: string }[]>;
68
+ }>;
47
69
  }
48
70
 
49
71
  export interface EntrySuiteOptions {
@@ -214,42 +236,125 @@ export function entryTests(
214
236
 
215
237
  define(
216
238
  "served.entry.framed",
217
- "a clean address in a frame shows the content where the browser keeps the cookies, else asks for a tab: never the app's sign-in",
239
+ "a clean address shown in a frame is resolved through issue first, then framed through its door: the content, never the app's sign-in",
218
240
  async ({ page, browserName }, info) => {
219
241
  await host.signIn(page);
220
242
  const before = page.url();
221
243
  const shown = await host.frame(page, await host.url("entry-framed"));
222
- const outcome = await shown.outcome();
244
+ expect(await shown.outcome(), "probe: the issued frame loaded").toEqual({ state: "loaded" });
223
245
  const frame = await shown.frame();
224
246
  expect(page.url(), "the app's page stays where it was").toBe(before);
225
- expect(new URL(frame.url()).pathname).not.toMatch(/sign-?in/iu);
226
- if (outcome.state === "loaded") {
227
- await expect(frame.locator("#artifact")).toHaveText("version 1");
228
- } else {
229
- expect(outcome).toMatchObject({ state: "blocked" });
230
- expect(["cookies", "sign-in"]).toContain((outcome as { readonly reason: string }).reason);
231
- expect(await shows(frame)).toBe(false);
232
- }
233
- const said = outcome.state === "blocked" ? `blocked: ${outcome.reason}` : outcome.state;
247
+ // An issued frame (P125): Porthole's own document address, never the clean address, and
248
+ // never the app's sign-in. Its access is the ticket's (P083), so every engine shows it.
249
+ expect(new URL(frame.url()).pathname, "probe: framed through issue").toMatch(
250
+ /^\/__porthole\/(d|f)\//u,
251
+ );
252
+ await expect(frame.locator("#artifact")).toHaveText("version 1");
234
253
  info.annotations.push({
235
254
  type: "measured",
236
- description: `${browserName}: framed entry ${said}`,
255
+ description: `${browserName}: framed entry loaded`,
237
256
  });
238
257
  },
239
258
  );
240
259
 
241
260
  define(
242
261
  "served.entry.framed-signed-out",
243
- "signed out, a clean address in a frame asks for a tab to sign in: the sign-in never shows in a frame",
262
+ "signed out, a clean address shown in a frame builds no frame: issue says sign in, and the fallback comes from that answer",
244
263
  async ({ page }) => {
245
264
  await host.signIn(page);
246
265
  // The app's page stays; the browser forgets every sign-in.
247
266
  await page.context().clearCookies();
248
267
  const shown = await host.frame(page, await host.url("entry-framed-out"));
249
- expect(await shown.outcome()).toMatchObject({ state: "blocked", reason: "sign-in" });
250
- const frame = await shown.frame();
251
- await expect(frame.locator("h1")).toHaveText("Open this in a new tab to sign in");
252
- expect(await shows(frame)).toBe(false);
268
+ expect(await shown.outcome(), "probe: issue's answer is the outcome").toEqual({
269
+ state: "blocked",
270
+ reason: "sign-in",
271
+ status: 401,
272
+ });
273
+ expect(await shown.framed(), "probe: no frame was made").toBe(false);
274
+ },
275
+ );
276
+
277
+ define(
278
+ "served.entry.framed-denied",
279
+ "a clean address its viewer may not open, shown in a frame, builds no frame: issue says denied",
280
+ async ({ page }, info) => {
281
+ info.skip(
282
+ host.denied === undefined,
283
+ "the host gave no address its viewer may not open (denied)",
284
+ );
285
+ await host.signIn(page);
286
+ const shown = await host.frame(page, (await host.denied?.("entry-framed-denied")) ?? "");
287
+ expect(await shown.outcome(), "probe: issue's answer is the outcome").toMatchObject({
288
+ state: "blocked",
289
+ reason: "denied",
290
+ status: 403,
291
+ });
292
+ expect(await shown.framed(), "probe: no frame was made").toBe(false);
293
+ },
294
+ );
295
+
296
+ define(
297
+ "served.entry.framed-not-found",
298
+ "a clean address that names nothing, shown in a frame, builds no frame: issue says not found",
299
+ async ({ page }, info) => {
300
+ const unknown = (await host.unknown?.()) ?? [];
301
+ // An address under a label the app never assigns: the first one that has a path.
302
+ const address = unknown.find((each) => new URL(each).hostname.split(".").length > 2);
303
+ info.skip(address === undefined, "the host gave no address that names nothing (unknown)");
304
+ await host.signIn(page);
305
+ const shown = await host.frame(page, address ?? "");
306
+ expect(await shown.outcome(), "probe: issue's answer is the outcome").toEqual({
307
+ state: "blocked",
308
+ reason: "not-found",
309
+ status: 404,
310
+ });
311
+ expect(await shown.framed(), "probe: no frame was made").toBe(false);
312
+ },
313
+ );
314
+
315
+ define(
316
+ "served.entry.in-a-frame",
317
+ "a clean address framed as it is goes nowhere: the host refuses it (no door), and the content origin answers a page with no script, never the app",
318
+ async ({ page }) => {
319
+ await host.signIn(page);
320
+ const url = await host.url("entry-in-a-frame");
321
+ // The host's own createHost, given the clean address as a location: refused before any
322
+ // frame (a served display needs a door from issue), and told why.
323
+ const direct = await host.frameDirectly(page, url);
324
+ expect(await direct.outcome(), "probe: refused before any frame").toEqual({
325
+ state: "blocked",
326
+ reason: "locate",
327
+ });
328
+ expect(await direct.framed(), "probe: no frame was made").toBe(false);
329
+ expect(
330
+ (await direct.hostErrors()).map((each) => each.kind),
331
+ "probe: the host heard why (door)",
332
+ ).toContain("door");
333
+ // A plain frame of the app's page at the clean address: the content origin answers it with
334
+ // a page of its own that has no script and goes nowhere (never the app's authorize).
335
+ const seen = await page.evaluate(async (address) => {
336
+ const frame = document.createElement("iframe");
337
+ const loaded = new Promise((resolve) =>
338
+ frame.addEventListener("load", resolve, { once: true }),
339
+ );
340
+ frame.src = address;
341
+ document.body.append(frame);
342
+ await loaded;
343
+ await new Promise((resolve) => setTimeout(resolve, 300));
344
+ return frame.getAttribute("src");
345
+ }, url);
346
+ expect(seen).toBe(url);
347
+ const frame = page.frames().find((each) => each.url() === url);
348
+ expect(
349
+ frame,
350
+ "probe: the frame stayed on the clean address (never the app's authorize)",
351
+ ).toBeDefined();
352
+ expect(
353
+ await frame?.locator("script").count(),
354
+ "probe: the page in the frame has no script",
355
+ ).toBe(0);
356
+ await expect(frame!.locator("h1")).toHaveText("Open this in a new tab");
357
+ expect(await shows(frame!), "probe: no content in the frame").toBe(false);
253
358
  },
254
359
  );
255
360
 
@@ -1,7 +1,7 @@
1
1
  import type { CapabilityHandlers, ConfirmRequest } from "../../bridge/types.ts";
2
2
  import type { PortholeConfig } from "../../config/schema.ts";
3
3
  import { createHost } from "../../host/create-host.ts";
4
- import { httpLocator } from "../../host/locator.ts";
4
+ import { httpLocator, resolveAddress } from "../../host/locator.ts";
5
5
  import type { DisplayEvents, DisplayHandle } from "../../host/types.ts";
6
6
  import type { FrameLocation, InstanceLocator, InstanceRef } from "../../isolation/types.ts";
7
7
  import type { LaunchSpec, RecordedCall, RecordedEvent } from "../index.ts";
@@ -108,6 +108,73 @@ addEventListener("message", (event) => {
108
108
  }
109
109
  });
110
110
 
111
+ /** A display's record, before anything is mounted for it (a no-op handle until then). */
112
+ function recordOf(id: number): Shown {
113
+ box(id, 600, 400);
114
+ const idle = { destroy() {}, setContent() {}, setTheme() {}, on: () => () => {} };
115
+ const shown: Shown = {
116
+ handle: idle as unknown as DisplayHandle,
117
+ calls: [],
118
+ events: [],
119
+ confirmations: [],
120
+ disclosed: [],
121
+ received: [],
122
+ origin: null,
123
+ failure: null,
124
+ frame: null,
125
+ };
126
+ displays.set(id, shown);
127
+ return shown;
128
+ }
129
+
130
+ /** Mounts a served display in its box, located by `asked` (the issue endpoint, or a location). */
131
+ function mountServed(
132
+ id: number,
133
+ shown: Shown,
134
+ config: PortholeConfig,
135
+ instance: InstanceRef,
136
+ asked: InstanceLocator,
137
+ content?: string,
138
+ ): void {
139
+ const container = document.getElementById(`porthole-display-${id}`) as HTMLElement;
140
+ const locator: InstanceLocator = {
141
+ async locate(each, signal) {
142
+ try {
143
+ const location = await asked.locate(each, signal);
144
+ shown.origin = location.origin;
145
+ return location;
146
+ } catch (error) {
147
+ shown.failure = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
148
+ throw error;
149
+ }
150
+ },
151
+ };
152
+ const handle = createHost(config, {
153
+ handlers: recorder(shown.calls),
154
+ locator,
155
+ hostInfo: { name: "porthole-conformance", version: "1" },
156
+ ...(nonce === undefined ? {} : { nonce }),
157
+ }).mount(container, {
158
+ displayId: `display-${id}`,
159
+ title: "Probe",
160
+ scheme: "light",
161
+ instance,
162
+ });
163
+ (shown as { handle: DisplayHandle }).handle = handle;
164
+ watch(id, shown);
165
+ // The frame element, once it exists, so its messages can be told from others' (never a door).
166
+ const found = () => {
167
+ shown.frame = container.querySelector("iframe:not([data-porthole-door])");
168
+ if (shown.frame === null) {
169
+ requestAnimationFrame(found);
170
+ }
171
+ };
172
+ found();
173
+ if (content !== undefined) {
174
+ handle.setContent(content);
175
+ }
176
+ }
177
+
111
178
  const harness = {
112
179
  /** An opaque display with the suite's content (the leak suite's `launch`). */
113
180
  async launch(spec: LaunchSpec): Promise<number> {
@@ -178,63 +245,59 @@ const harness = {
178
245
  ): number {
179
246
  const id = next;
180
247
  next += 1;
181
- const container = box(id, 600, 400);
182
- const calls: RecordedCall[] = [];
183
- const shown: Shown = {
184
- handle: null as unknown as DisplayHandle,
185
- calls,
186
- events: [],
187
- confirmations: [],
188
- disclosed: [],
189
- received: [],
190
- origin: null,
191
- failure: null,
192
- frame: null,
193
- };
248
+ const shown = recordOf(id);
194
249
  const asked: InstanceLocator =
195
250
  "issue" in where
196
251
  ? httpLocator(where.issue, where.headers === undefined ? {} : { headers: where.headers })
197
252
  : { locate: () => Promise.resolve(where.location) };
198
- const locator: InstanceLocator = {
199
- async locate(each, signal) {
200
- try {
201
- const location = await asked.locate(each, signal);
202
- shown.origin = location.origin;
203
- return location;
204
- } catch (error) {
205
- shown.failure =
206
- error instanceof Error ? `${error.name}: ${error.message}` : String(error);
207
- throw error;
253
+ mountServed(id, shown, config, instance, asked, content);
254
+ return id;
255
+ },
256
+
257
+ /**
258
+ * A clean address, shown as a host shows one (P125): resolved through the app's issue endpoint
259
+ * first (`{ address }`, `resolveAddress`), then framed through the location it issued (its
260
+ * door); signed out, denied or not found, the answer is the display's outcome and no frame is
261
+ * ever made. Later runs issue afresh by the resolved instance.
262
+ */
263
+ showAddress(
264
+ config: PortholeConfig,
265
+ where: { readonly issue: string; readonly headers?: Readonly<Record<string, string>> },
266
+ address: string,
267
+ ): number {
268
+ const id = next;
269
+ next += 1;
270
+ const shown = recordOf(id);
271
+ const options = where.headers === undefined ? {} : { headers: where.headers };
272
+ void resolveAddress(where.issue, address, options).then(
273
+ (resolved) => {
274
+ if ("outcome" in resolved) {
275
+ shown.events.push({ type: "outcome", detail: resolved.outcome });
276
+ return;
208
277
  }
278
+ shown.origin = resolved.location.origin;
279
+ let first: FrameLocation | null = resolved.location;
280
+ const byInstance = httpLocator(where.issue, options);
281
+ const asked: InstanceLocator = {
282
+ locate(each, signal) {
283
+ const given = first;
284
+ first = null;
285
+ return given === null ? byInstance.locate(each, signal) : Promise.resolve(given);
286
+ },
287
+ };
288
+ mountServed(id, shown, config, resolved.instance, asked);
209
289
  },
210
- };
211
- const handle = createHost(config, {
212
- handlers: recorder(calls),
213
- locator,
214
- hostInfo: { name: "porthole-conformance", version: "1" },
215
- ...(nonce === undefined ? {} : { nonce }),
216
- }).mount(container, {
217
- displayId: `display-${id}`,
218
- title: "Probe",
219
- scheme: "light",
220
- instance,
221
- });
222
- (shown as { handle: DisplayHandle }).handle = handle;
223
- watch(id, shown);
224
- // The frame element, once it exists, so its messages can be told from others'.
225
- const found = () => {
226
- shown.frame = container.querySelector("iframe");
227
- if (shown.frame === null) {
228
- requestAnimationFrame(found);
229
- }
230
- };
231
- found();
232
- if (content !== undefined) {
233
- handle.setContent(content);
234
- }
290
+ (error: unknown) => {
291
+ shown.failure = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
292
+ },
293
+ );
235
294
  return id;
236
295
  },
237
296
 
297
+ /** Whether a display's frame was ever made (P125: a refused clean address makes none). */
298
+ framed: (id: number) =>
299
+ (document.getElementById(`porthole-display-${id}`)?.querySelector("iframe") ?? null) !== null,
300
+
238
301
  origin: (id: number) => displays.get(id)?.origin ?? null,
239
302
  failure: (id: number) => displays.get(id)?.failure ?? null,
240
303
  received: (id: number) => displays.get(id)?.received ?? [],
@@ -138,12 +138,30 @@ function invoke<K extends keyof ConformanceHarness>(
138
138
  }
139
139
 
140
140
  /** The display's frame element's document, once it exists. */
141
+ /** A display's first outcome, once it has one (P040, P125). */
142
+ async function outcomeOf(page: Page, id: number): Promise<FrameOutcome> {
143
+ let found: FrameOutcome | null = null;
144
+ await expect
145
+ .poll(
146
+ async () => {
147
+ const events = await invoke(page, "events", id);
148
+ const each = events.find((event) => event.type === "outcome");
149
+ found = each === undefined ? null : each.detail;
150
+ return found !== null;
151
+ },
152
+ { message: "the display has an outcome", timeout: 15_000 },
153
+ )
154
+ .toBe(true);
155
+ return found as unknown as FrameOutcome;
156
+ }
157
+
141
158
  async function frameIn(page: Page, id: number): Promise<Frame> {
142
159
  let found: Frame | null = null;
143
160
  await expect
144
161
  .poll(async () => {
145
162
  const element = await page
146
- .locator(`#porthole-display-${id} iframe`)
163
+ // The display's own frame, never its door (P125), which is gone once it said its word.
164
+ .locator(`#porthole-display-${id} iframe:not([data-porthole-door])`)
147
165
  .elementHandle({ timeout: 2_000 })
148
166
  .catch(() => null);
149
167
  found = (await element?.contentFrame()) ?? null;
@@ -369,27 +387,45 @@ export function hostConformance(options: HostConformanceOptions): HostConformanc
369
387
  : given.unknown,
370
388
  }),
371
389
  async frame(page, url) {
390
+ await ready(page);
391
+ if (options.issue === undefined) {
392
+ throw new Error(
393
+ "A clean address is framed through the app's issue endpoint ({ address }, P125): give defineHostConformance its issue",
394
+ );
395
+ }
396
+ const instance = await served.artifact("entry", "1");
397
+ const id = await invoke(
398
+ page,
399
+ "showAddress",
400
+ configOf(instance),
401
+ {
402
+ issue: options.issue.url,
403
+ ...(options.issue.headers === undefined ? {} : { headers: options.issue.headers }),
404
+ },
405
+ url,
406
+ );
407
+ return {
408
+ frame: () => frameIn(page, id),
409
+ outcome: () => outcomeOf(page, id),
410
+ framed: () => invoke(page, "framed", id),
411
+ };
412
+ },
413
+ async frameDirectly(page, url) {
372
414
  await ready(page);
373
415
  const instance = await served.artifact("entry", "1");
374
416
  const id = await invoke(page, "show", configOf(instance), instance, {
375
417
  location: { url, origin: new URL(url).origin },
376
418
  });
377
419
  return {
378
- frame: () => frameIn(page, id),
379
- async outcome(): Promise<FrameOutcome> {
380
- let found: FrameOutcome | null = null;
381
- await expect
382
- .poll(
383
- async () => {
384
- const events = await invoke(page, "events", id);
385
- const each = events.find((event) => event.type === "outcome");
386
- found = each === undefined ? null : each.detail;
387
- return found !== null;
388
- },
389
- { message: "the display has an outcome", timeout: 15_000 },
390
- )
391
- .toBe(true);
392
- return found as unknown as FrameOutcome;
420
+ outcome: () => outcomeOf(page, id),
421
+ framed: () => invoke(page, "framed", id),
422
+ async hostErrors() {
423
+ const events = await invoke(page, "events", id);
424
+ return events.flatMap((event) =>
425
+ event.type === "hostError"
426
+ ? [event.detail as { readonly message: string; readonly kind: string }]
427
+ : [],
428
+ );
393
429
  },
394
430
  };
395
431
  },
@@ -450,6 +486,7 @@ const DOMAIN_CASES = [
450
486
  "served.domain.self-navigation",
451
487
  ...TAB_CASES,
452
488
  "served.domain.frame-ancestors",
489
+ "served.domain.door",
453
490
  "served.domain.egress",
454
491
  ];
455
492