@variance-authority/unit-test 0.1.0

package/dist/collector.js

@@ -0,0 +1,65 @@
+import { captureFiles, readCapture } from './archive.js';
+import { operatorError } from './operator.js';
+/** Read browserless unit-test captures in a later `variance run` process. */
+export function captureCollector(options) {
+    return async () => {
+        const artifacts = new Map();
+        const load = async () => {
+            if (artifacts.size > 0)
+                return;
+            for (const path of await captureFiles(options.directory)) {
+                const artifact = await readCapture(path);
+                if (artifacts.has(artifact.subject.id)) {
+                    throw operatorError(`capture directory contains duplicate subject ${artifact.subject.id}`);
+                }
+                artifacts.set(artifact.subject.id, artifact);
+            }
+            if (artifacts.size === 0) {
+                throw operatorError(`capture directory ${options.directory} contains no capture artifacts`);
+            }
+        };
+        return {
+            async plan() {
+                await load();
+                return {
+                    subjects: [...artifacts.values()].map((artifact) => ({
+                        subject: artifact.subject,
+                        ...(artifact.material.kind === 'document'
+                            ? { viewport: artifact.material.document.viewport }
+                            : {}),
+                    })),
+                    notObserved: [],
+                    warnings: [],
+                };
+            },
+            async collect(subject) {
+                await load();
+                const artifact = artifacts.get(subject.subject.id);
+                if (artifact === undefined) {
+                    return { ok: false, because: `no capture artifact for ${subject.subject.id}` };
+                }
+                if (artifact.material.kind !== 'document') {
+                    // FIXME: `Collected` carries a render document, so a value capture has
+                    // nowhere to land. Spec 0031 gives it a value arm and an observation
+                    // that files changes rather than regions; until then the run says so.
+                    return {
+                        ok: false,
+                        because: `${subject.subject.id} is a ${artifact.material.kind} capture, and this run ` +
+                            'compares rendered documents',
+                    };
+                }
+                return {
+                    ok: true,
+                    document: artifact.material.document,
+                    ...(artifact.snapshot === undefined ? {} : { snapshot: artifact.snapshot }),
+                    ...(artifact.source === undefined ? {} : { source: artifact.source }),
+                    ...(artifact.stabilization === undefined
+                        ? {}
+                        : { stabilization: artifact.stabilization }),
+                };
+            },
+            async close() { },
+        };
+    };
+}
+//# sourceMappingURL=collector.js.map

package/dist/collector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.js","sourceRoot":"","sources":["../src/collector.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CaptureArtifact } from '@variance-authority/core';\nimport { captureFiles, readCapture } from './archive.js';\nimport type { Collector, SubjectSource } from './contract.js';\nimport { operatorError } from './operator.js';\n\nexport interface CaptureCollectorOptions {\n  readonly directory: string;\n}\n\n/** Read browserless unit-test captures in a later `variance run` process. */\nexport function captureCollector(options: CaptureCollectorOptions): SubjectSource {\n  return async (): Promise<Collector> => {\n    const artifacts = new Map<string, CaptureArtifact>();\n\n    const load = async (): Promise<void> => {\n      if (artifacts.size > 0) return;\n      for (const path of await captureFiles(options.directory)) {\n        const artifact = await readCapture(path);\n        if (artifacts.has(artifact.subject.id)) {\n          throw operatorError(`capture directory contains duplicate subject ${artifact.subject.id}`);\n        }\n        artifacts.set(artifact.subject.id, artifact);\n      }\n      if (artifacts.size === 0) {\n        throw operatorError(`capture directory ${options.directory} contains no capture artifacts`);\n      }\n    };\n\n    return {\n      async plan() {\n        await load();\n        return {\n          subjects: [...artifacts.values()].map((artifact) => ({\n            subject: artifact.subject,\n            ...(artifact.material.kind === 'document'\n              ? { viewport: artifact.material.document.viewport }\n              : {}),\n          })),\n          notObserved: [],\n          warnings: [],\n        };\n      },\n\n      async collect(subject) {\n        await load();\n        const artifact = artifacts.get(subject.subject.id);\n        if (artifact === undefined) {\n          return { ok: false, because: `no capture artifact for ${subject.subject.id}` };\n        }\n        if (artifact.material.kind !== 'document') {\n          // FIXME: `Collected` carries a render document, so a value capture has\n          // nowhere to land. Spec 0031 gives it a value arm and an observation\n          // that files changes rather than regions; until then the run says so.\n          return {\n            ok: false,\n            because:\n              `${subject.subject.id} is a ${artifact.material.kind} capture, and this run ` +\n              'compares rendered documents',\n          };\n        }\n        return {\n          ok: true,\n          document: artifact.material.document,\n          ...(artifact.snapshot === undefined ? {} : { snapshot: artifact.snapshot }),\n          ...(artifact.source === undefined ? {} : { source: artifact.source }),\n          ...(artifact.stabilization === undefined\n            ? {}\n            : { stabilization: artifact.stabilization }),\n        };\n      },\n\n      async close() {},\n    };\n  };\n}\n"]}

package/dist/contract.d.ts

@@ -0,0 +1,36 @@
+import type { CallSiteResolver, RenderDocument, SemanticSnapshot, SourceIndex, SubjectRef, Viewport } from '@variance-authority/core';
+/** Structural copy of the CLI collector boundary; this surface does not import the binary. */
+export interface PlannedSubject {
+    readonly subject: SubjectRef;
+    readonly viewport?: Viewport;
+    readonly tags?: readonly string[];
+}
+export interface Plan {
+    readonly subjects: readonly PlannedSubject[];
+    readonly notObserved: readonly unknown[];
+    readonly warnings: readonly string[];
+}
+export type Collected = {
+    readonly ok: true;
+    readonly document: RenderDocument;
+    readonly snapshot?: SemanticSnapshot;
+    readonly source?: SourceIndex;
+    readonly stabilization?: readonly string[];
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+export interface Collector {
+    plan(): Promise<Plan>;
+    collect(subject: PlannedSubject): Promise<Collected>;
+    readonly callSites?: CallSiteResolver;
+    close(): Promise<void>;
+}
+export interface CollectorContext {
+    readonly config: {
+        readonly viewport: Viewport;
+    };
+    readonly plan?: Plan;
+}
+export type SubjectSource = (context: CollectorContext) => Promise<Collector>;
+//# sourceMappingURL=contract.d.ts.map

package/dist/contract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contract.js.map

package/dist/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  CallSiteResolver,\n  RenderDocument,\n  SemanticSnapshot,\n  SourceIndex,\n  SubjectRef,\n  Viewport,\n} from '@variance-authority/core';\n\n/** Structural copy of the CLI collector boundary; this surface does not import the binary. */\nexport interface PlannedSubject {\n  readonly subject: SubjectRef;\n  readonly viewport?: Viewport;\n  readonly tags?: readonly string[];\n}\n\nexport interface Plan {\n  readonly subjects: readonly PlannedSubject[];\n  readonly notObserved: readonly unknown[];\n  readonly warnings: readonly string[];\n}\n\nexport type Collected =\n  | {\n      readonly ok: true;\n      readonly document: RenderDocument;\n      readonly snapshot?: SemanticSnapshot;\n      readonly source?: SourceIndex;\n      readonly stabilization?: readonly string[];\n    }\n  | { readonly ok: false; readonly because: string };\n\nexport interface Collector {\n  plan(): Promise<Plan>;\n  collect(subject: PlannedSubject): Promise<Collected>;\n  readonly callSites?: CallSiteResolver;\n  close(): Promise<void>;\n}\n\nexport interface CollectorContext {\n  readonly config: { readonly viewport: Viewport };\n  readonly plan?: Plan;\n}\n\nexport type SubjectSource = (context: CollectorContext) => Promise<Collector>;\n"]}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { capture } from './capture.js';
+export type { ResolvedResource, UnitCaptureOptions, } from './capture.js';
+export { snapshotValue } from './value.js';
+export type { SnapshotValueOptions } from './value.js';
+export { CAPTURE_SUFFIX, captureFiles, readCapture, resetCaptures, writeCapture, } from './archive.js';
+export { captureCollector } from './collector.js';
+export type { CaptureCollectorOptions } from './collector.js';
+export type { Collected, Collector, CollectorContext, Plan, PlannedSubject, SubjectSource, } from './contract.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export { capture } from './capture.js';
+export { snapshotValue } from './value.js';
+export { CAPTURE_SUFFIX, captureFiles, readCapture, resetCaptures, writeCapture, } from './archive.js';
+export { captureCollector } from './collector.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EACL,cAAc,EACd,YAAY,EACZ,WAAW,EACX,aAAa,EACb,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC","sourcesContent":["export { capture } from './capture.js';\nexport type {\n  ResolvedResource,\n  UnitCaptureOptions,\n} from './capture.js';\nexport { snapshotValue } from './value.js';\nexport type { SnapshotValueOptions } from './value.js';\nexport {\n  CAPTURE_SUFFIX,\n  captureFiles,\n  readCapture,\n  resetCaptures,\n  writeCapture,\n} from './archive.js';\nexport { captureCollector } from './collector.js';\nexport type { CaptureCollectorOptions } from './collector.js';\nexport type {\n  Collected,\n  Collector,\n  CollectorContext,\n  Plan,\n  PlannedSubject,\n  SubjectSource,\n} from './contract.js';\n"]}

package/dist/operator.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Say that a failure is the operator's to fix, not a bug in the tool.
+ *
+ * A collector is loaded by dynamic import from the adopter's own
+ * `node_modules`, so it cannot share an error *class* with whatever runs it —
+ * `instanceof` across two installed copies is `false`, and the misconfigured
+ * suite would be told it has found a defect. The contract is therefore a
+ * property name, which survives the boundary the way a header name does.
+ *
+ * Use it for anything the reader can act on: a config that names two plans, a
+ * sitemap that answered 404, a route with no id. Leave a bare `Error` where the
+ * cause really is this package — a missing bundle it was supposed to build is
+ * not something an adopter can repair, and dressing it up as their problem
+ * sends them to edit a config that was never wrong.
+ */
+export declare function operatorError(message: string, options?: ErrorOptions): Error;
+//# sourceMappingURL=operator.d.ts.map

package/dist/operator.js

@@ -0,0 +1,19 @@
+/**
+ * Say that a failure is the operator's to fix, not a bug in the tool.
+ *
+ * A collector is loaded by dynamic import from the adopter's own
+ * `node_modules`, so it cannot share an error *class* with whatever runs it —
+ * `instanceof` across two installed copies is `false`, and the misconfigured
+ * suite would be told it has found a defect. The contract is therefore a
+ * property name, which survives the boundary the way a header name does.
+ *
+ * Use it for anything the reader can act on: a config that names two plans, a
+ * sitemap that answered 404, a route with no id. Leave a bare `Error` where the
+ * cause really is this package — a missing bundle it was supposed to build is
+ * not something an adopter can repair, and dressing it up as their problem
+ * sends them to edit a config that was never wrong.
+ */
+export function operatorError(message, options) {
+    return Object.assign(new Error(message, options), { varianceOperatorError: true });
+}
+//# sourceMappingURL=operator.js.map

package/dist/operator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator.js","sourceRoot":"","sources":["../src/operator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa,CAAC,OAAe,EAAE,OAAsB;IACnE,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,CAAC,CAAC;AACrF,CAAC","sourcesContent":["/**\n * Say that a failure is the operator's to fix, not a bug in the tool.\n *\n * A collector is loaded by dynamic import from the adopter's own\n * `node_modules`, so it cannot share an error *class* with whatever runs it —\n * `instanceof` across two installed copies is `false`, and the misconfigured\n * suite would be told it has found a defect. The contract is therefore a\n * property name, which survives the boundary the way a header name does.\n *\n * Use it for anything the reader can act on: a config that names two plans, a\n * sitemap that answered 404, a route with no id. Leave a bare `Error` where the\n * cause really is this package — a missing bundle it was supposed to build is\n * not something an adopter can repair, and dressing it up as their problem\n * sends them to edit a config that was never wrong.\n */\nexport function operatorError(message: string, options?: ErrorOptions): Error {\n  return Object.assign(new Error(message, options), { varianceOperatorError: true });\n}\n"]}

package/dist/shape.d.ts

@@ -0,0 +1,18 @@
+import { type CaptureArtifact } from '@variance-authority/core';
+/**
+ * What a capture file has to be before anything is believed about it.
+ *
+ * Separate from the directory protocol in [`archive.ts`](./archive.ts) because
+ * the two answer different questions and change for different reasons: that one
+ * owns which files exist and who may replace them, this one owns whether the
+ * bytes in one of them are a capture. The split is also where the size is — a
+ * document carries a semantic snapshot, a resource closure and a source index,
+ * and every one of those is checked field by field here.
+ *
+ * Everything is re-derived rather than believed. A digest that arrived in the
+ * file is recomputed from the content it claims to describe, so a baseline
+ * edited by hand between runs fails here instead of comparing as though the edit
+ * had been captured.
+ */
+export declare function captureArtifactFrom(value: unknown, path: string): CaptureArtifact;
+//# sourceMappingURL=shape.d.ts.map

package/dist/shape.js

@@ -0,0 +1,365 @@
+import { digestBytes, digestCombine, digestString, } from '@variance-authority/core';
+/**
+ * What a capture file has to be before anything is believed about it.
+ *
+ * Separate from the directory protocol in [`archive.ts`](./archive.ts) because
+ * the two answer different questions and change for different reasons: that one
+ * owns which files exist and who may replace them, this one owns whether the
+ * bytes in one of them are a capture. The split is also where the size is — a
+ * document carries a semantic snapshot, a resource closure and a source index,
+ * and every one of those is checked field by field here.
+ *
+ * Everything is re-derived rather than believed. A digest that arrived in the
+ * file is recomputed from the content it claims to describe, so a baseline
+ * edited by hand between runs fails here instead of comparing as though the edit
+ * had been captured.
+ */
+export function captureArtifactFrom(value, path) {
+    const artifact = record(value);
+    if (artifact === null || artifact.artifactVersion !== 1) {
+        throw new Error(`${path} is not a capture artifact version 1`);
+    }
+    const subject = subjectFrom(artifact.subject);
+    const material = record(artifact.material);
+    if (subject === null || material === null) {
+        throw new Error(`${path} is not a unit-test capture`);
+    }
+    if (material.kind === 'value') {
+        checkValue(material.value, path);
+        checkTail(artifact, subject.id, path);
+        return value;
+    }
+    if (material.kind !== 'document') {
+        throw new Error(`${path} is not a unit-test document capture`);
+    }
+    const document = record(material.document);
+    if (document === null ||
+        !documentShape(document) ||
+        record(document.resources) === null) {
+        throw new Error(`${path} does not contain a resource-closed render document`);
+    }
+    const documentSubject = subjectFrom(document.subject);
+    if (documentSubject === null || documentSubject.id !== subject.id) {
+        throw new Error(`${path} has different artifact and document subjects`);
+    }
+    for (const [url, value] of Object.entries(document.resources)) {
+        const resource = resourceFrom(value);
+        if (resource === null)
+            throw new Error(`${path} contains an invalid resource for ${url}`);
+        const actual = digestBytes(Buffer.from(resource.bytes, 'base64'));
+        if (actual !== resource.digest) {
+            throw new Error(`${path} contains resource bytes that do not match ${url}`);
+        }
+    }
+    const assets = record(document.assets);
+    if (assets === null)
+        throw new Error(`${path} does not declare its resource digests`);
+    for (const [url, expected] of Object.entries(assets)) {
+        const resource = document.resources[url];
+        const parsed = resourceFrom(resource);
+        if (typeof expected !== 'string' || parsed === null || parsed.digest !== expected) {
+            throw new Error(`${path} has no matching archived resource for ${url}`);
+        }
+    }
+    checkTail(artifact, subject.id, path);
+    return value;
+}
+function checkTail(artifact, subjectId, path) {
+    if (artifact.snapshot !== undefined && !snapshotShape(artifact.snapshot, subjectId)) {
+        throw new Error(`${path} contains an invalid semantic snapshot`);
+    }
+    if (artifact.source !== undefined && !sourceShape(artifact.source)) {
+        throw new Error(`${path} contains an invalid source index`);
+    }
+    if (artifact.stabilization !== undefined && !stringArray(artifact.stabilization)) {
+        throw new Error(`${path} contains an invalid stabilization record`);
+    }
+    if (artifact.attempt !== undefined && !attemptShape(artifact.attempt)) {
+        throw new Error(`${path} contains an invalid capture attempt`);
+    }
+}
+/**
+ * A value capture, re-derived rather than believed.
+ *
+ * The digest is recomputed from the text on the way in, exactly as a resource's
+ * bytes are. A baseline edited by hand between runs would otherwise pass its own
+ * identity check and compare as though the edit had been captured.
+ */
+function checkValue(value, path) {
+    const captured = record(value);
+    if (captured === null ||
+        typeof captured.dialect !== 'string' ||
+        typeof captured.text !== 'string' ||
+        typeof captured.digest !== 'string' ||
+        typeof captured.recipe !== 'string' ||
+        (captured.keyed !== undefined && !stringArray(captured.keyed)) ||
+        (captured.generator !== undefined && !generatorShape(captured.generator))) {
+        throw new Error(`${path} does not contain a captured value`);
+    }
+    const actual = digestCombine('value/v1', [
+        digestString(captured.text),
+        digestString(captured.recipe),
+    ]);
+    if (actual !== captured.digest) {
+        throw new Error(`${path} contains value text that does not match its digest`);
+    }
+}
+function generatorShape(value) {
+    const generator = record(value);
+    return (generator !== null &&
+        typeof generator.name === 'string' &&
+        typeof generator.version === 'string');
+}
+function resourceFrom(value) {
+    const resource = record(value);
+    return resource !== null &&
+        typeof resource.contentType === 'string' &&
+        typeof resource.bytes === 'string' &&
+        base64(resource.bytes) &&
+        typeof resource.digest === 'string'
+        ? resource
+        : null;
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function subjectFrom(value) {
+    const subject = record(value);
+    if (subject === null ||
+        typeof subject.id !== 'string' ||
+        !['story', 'route', 'fixture', 'value'].includes(String(subject.kind)) ||
+        (subject.title !== undefined && typeof subject.title !== 'string'))
+        return null;
+    return { id: subject.id, kind: String(subject.kind) };
+}
+function documentShape(document) {
+    const frame = record(document.frame);
+    const viewport = record(document.viewport);
+    return (document.documentVersion === 1 &&
+        subjectFrom(document.subject) !== null &&
+        typeof document.html === 'string' &&
+        frame !== null &&
+        stringRecord(frame.html) &&
+        stringRecord(frame.body) &&
+        Array.isArray(frame.ancestors) &&
+        frame.ancestors.every(frameElementShape) &&
+        (frame.containerWidth === undefined || finiteNumber(frame.containerWidth)) &&
+        stringArray(document.css) &&
+        viewport !== null &&
+        finiteNumber(viewport.width) &&
+        finiteNumber(viewport.height) &&
+        finiteNumber(viewport.deviceScaleFactor) &&
+        (viewport.colorScheme === 'light' || viewport.colorScheme === 'dark') &&
+        stringRecord(document.inherited) &&
+        stringArray(document.fonts) &&
+        (document.assets === undefined || stringRecord(document.assets)) &&
+        (document.baseUrl === undefined || typeof document.baseUrl === 'string') &&
+        diagnosticArray(document.diagnostics));
+}
+function frameElementShape(value) {
+    const element = record(value);
+    return element !== null && typeof element.tag === 'string' && stringRecord(element.attributes);
+}
+function snapshotShape(value, subjectId) {
+    const snapshot = record(value);
+    const profile = snapshot === null ? null : record(snapshot.profile);
+    const environment = snapshot === null ? null : record(snapshot.environment);
+    const root = snapshot === null ? null : record(snapshot.root);
+    return (snapshot !== null &&
+        snapshot.formatVersion === 1 &&
+        subjectFrom(snapshot.subject)?.id === subjectId &&
+        profile !== null &&
+        (profile.id === 'jsdom' || profile.id === 'chromium') &&
+        ['ariaTree', 'declaredStyle', 'computedStyle', 'layout', 'raster'].every((field) => typeof profile[field] === 'boolean') &&
+        environment !== null &&
+        typeof environment.digest === 'string' &&
+        typeof environment.semanticDigest === 'string' &&
+        environmentInputsShape(environment.inputs) &&
+        typeof snapshot.renderHash === 'string' &&
+        typeof snapshot.structureHash === 'string' &&
+        typeof snapshot.styleHash === 'string' &&
+        root !== null &&
+        semanticNodeShape(root) &&
+        Array.isArray(snapshot.styleProvenance) &&
+        snapshot.styleProvenance.every(styleProvenanceShape) &&
+        (snapshot.ignoreSites === undefined ||
+            (Array.isArray(snapshot.ignoreSites) && snapshot.ignoreSites.every(ignoreSiteShape))) &&
+        diagnosticArray(snapshot.diagnostics));
+}
+function environmentInputsShape(value) {
+    const inputs = record(value);
+    const viewport = inputs === null ? null : record(inputs.viewport);
+    return inputs !== null &&
+        (inputs.profile === 'jsdom' || inputs.profile === 'chromium') &&
+        typeof inputs.engine === 'string' &&
+        typeof inputs.ruleset === 'string' &&
+        typeof inputs.allowlist === 'string' &&
+        viewport !== null &&
+        finiteNumber(viewport.width) &&
+        finiteNumber(viewport.height) &&
+        finiteNumber(viewport.deviceScaleFactor) &&
+        (viewport.colorScheme === 'light' || viewport.colorScheme === 'dark') &&
+        stringArray(inputs.fonts) &&
+        scalarRecord(inputs.conditions) &&
+        stringRecord(inputs.assets) &&
+        (inputs.stabilization === undefined || typeof inputs.stabilization === 'string');
+}
+function styleProvenanceShape(value) {
+    const entry = record(value);
+    if (entry === null ||
+        typeof entry.path !== 'string' ||
+        typeof entry.property !== 'string' ||
+        typeof entry.sheet !== 'string' ||
+        typeof entry.selector !== 'string' ||
+        (entry.tokenName !== undefined && typeof entry.tokenName !== 'string'))
+        return false;
+    if (entry.source === undefined)
+        return true;
+    const source = record(entry.source);
+    return source !== null && typeof source.file === 'string' && finiteNumber(source.line);
+}
+function semanticNodeShape(node) {
+    return (typeof node.path === 'string' &&
+        typeof node.tag === 'string' &&
+        optionalString(node.alias) &&
+        optionalString(node.role) &&
+        optionalString(node.name) &&
+        optionalString(node.description) &&
+        (node.state === undefined || scalarRecord(node.state)) &&
+        stringRecord(node.attributes) &&
+        stringRecord(node.style) &&
+        (node.tokens === undefined || stringRecord(node.tokens)) &&
+        (node.styleTokens === undefined || stringRecord(node.styleTokens)) &&
+        (node.rect === undefined || rectShape(node.rect)) &&
+        optionalString(node.text) &&
+        (node.provenance === undefined || provenanceShape(node.provenance)) &&
+        (node.wiring === undefined || wiringShape(node.wiring)) &&
+        (node.portalled === undefined || typeof node.portalled === 'boolean') &&
+        (node.ignoredBy === undefined || stringArray(node.ignoredBy)) &&
+        Array.isArray(node.children) &&
+        node.children.every((child) => {
+            const parsed = record(child);
+            return parsed !== null && semanticNodeShape(parsed);
+        }));
+}
+function ignoreSiteShape(value) {
+    const site = record(value);
+    return site !== null &&
+        typeof site.path === 'string' &&
+        typeof site.rule === 'string' &&
+        (site.rect === undefined || rectShape(site.rect));
+}
+function rectShape(value) {
+    const rect = record(value);
+    return rect !== null &&
+        finiteNumber(rect.x) &&
+        finiteNumber(rect.y) &&
+        finiteNumber(rect.width) &&
+        finiteNumber(rect.height);
+}
+function provenanceShape(value) {
+    const provenance = record(value);
+    return provenance !== null &&
+        Array.isArray(provenance.owners) &&
+        provenance.owners.every(ownerShape) &&
+        optionalString(provenance.createdBy) &&
+        (provenance.source === undefined || sourceLocationShape(provenance.source)) &&
+        (provenance.stack === undefined ||
+            (Array.isArray(provenance.stack) && provenance.stack.every(stackFrameShape)));
+}
+function ownerShape(value) {
+    const owner = record(value);
+    return owner !== null &&
+        typeof owner.name === 'string' &&
+        typeof owner.propsDigest === 'string' &&
+        optionalString(owner.createdBy);
+}
+function sourceLocationShape(value) {
+    const source = record(value);
+    return source !== null &&
+        typeof source.file === 'string' &&
+        finiteNumber(source.line) &&
+        finiteNumber(source.column);
+}
+function stackFrameShape(value) {
+    const frame = record(value);
+    return frame !== null &&
+        typeof frame.url === 'string' &&
+        finiteNumber(frame.line) &&
+        finiteNumber(frame.column) &&
+        optionalString(frame.function);
+}
+function wiringShape(value) {
+    const wiring = record(value);
+    return wiring !== null &&
+        (wiring.hooks === undefined || stringArray(wiring.hooks)) &&
+        (wiring.wrappers === undefined ||
+            (Array.isArray(wiring.wrappers) &&
+                wiring.wrappers.every((entry) => entry === 'memo' || entry === 'forwardRef'))) &&
+        (wiring.contexts === undefined || stringArray(wiring.contexts)) &&
+        optionalString(wiring.key);
+}
+function sourceShape(value) {
+    const source = record(value);
+    return source !== null && Object.values(source).every((refs) => Array.isArray(refs) && refs.every((ref) => {
+        const parsed = record(ref);
+        return parsed !== null &&
+            typeof parsed.file === 'string' &&
+            finiteNumber(parsed.line) &&
+            ['function', 'const', 'class', 'declared'].includes(String(parsed.via));
+    }));
+}
+function attemptShape(value) {
+    const attempt = record(value);
+    if (attempt === null ||
+        !nonNegativeInteger(attempt.retry) ||
+        !nonNegativeInteger(attempt.repeat))
+        return false;
+    if (attempt.shard === undefined)
+        return true;
+    const shard = record(attempt.shard);
+    return shard !== null &&
+        nonNegativeInteger(shard.index) &&
+        nonNegativeInteger(shard.total) &&
+        Number(shard.total) > 0 &&
+        Number(shard.index) < Number(shard.total);
+}
+function diagnosticArray(value) {
+    return Array.isArray(value) && value.every((entry) => {
+        const diagnostic = record(entry);
+        return diagnostic !== null &&
+            (diagnostic.severity === 'warn' || diagnostic.severity === 'error') &&
+            typeof diagnostic.code === 'string' &&
+            typeof diagnostic.message === 'string' &&
+            (diagnostic.nodePath === undefined || typeof diagnostic.nodePath === 'string');
+    });
+}
+function stringRecord(value) {
+    const parsed = record(value);
+    return parsed !== null && Object.values(parsed).every((entry) => typeof entry === 'string');
+}
+function scalarRecord(value) {
+    const parsed = record(value);
+    return parsed !== null && Object.values(parsed).every((entry) => ['string', 'boolean', 'number'].includes(typeof entry) &&
+        (typeof entry !== 'number' || Number.isFinite(entry)));
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+function optionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function nonNegativeInteger(value) {
+    return finiteNumber(value) && Number.isInteger(value) && Number(value) >= 0;
+}
+function base64(value) {
+    if (value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value))
+        return false;
+    return Buffer.from(value, 'base64').toString('base64') === value;
+}
+//# sourceMappingURL=shape.js.map