capturebatch

func BuildEnvelope ¶

func BuildEnvelope(url string, capturedAt time.Time, stripped map[string]any, http *firefox.HTTPResponse) ([]byte, error)

BuildEnvelope assembles the envelope artifact for a resolved capture and returns the JCS-canonicalized bytes. When http is non-nil, emits the full v1 schema with http.* fields populated; when nil, emits v1-preview with the http key omitted.

Per RFC 0001 §Envelope Artifact:

• `schema`, `url`, `captured_at` are required.
• `http.status`, `http.headers` are required by the RFC v1 but only present when the backend supports network-event capture.
• `stripped.<format>` is optional; the format normalizer returns what it removed, or nil if nothing.

func BuildSpec ¶

func BuildSpec(
	r Resolved,
	browser firefox.BrowserInfo,
	host HostFingerprint,
	capturerVersion string,
) ([]byte, error)

BuildSpec assembles the spec artifact for a resolved capture and returns the JCS-canonicalized bytes.

Per RFC 0001 §Capture Spec Artifact:

• `capture.options` is an echo of the input (may be any JSON value); empty object `{}` if input omitted it.
• `browser.command_line`, `browser.prefs`, `browser.extensions[].manifest_digest` are optional; omitted when empty (vs present-and-empty).
• `browser.extensions` is required; must be `[]` if none.
• MUST NOT contain time-varying data.

func Canonicalize ¶

func Canonicalize(v any) ([]byte, error)

Canonicalize encodes v as JCS (RFC 8785) bytes.

Our schema uses strings, integers, booleans, objects, arrays, and null — no floating-point numbers. This implementation is correct for that subset:

• map keys are sorted by UTF-16 code units (same as alphabetical for ASCII-only keys, which our schema uses);
• objects and arrays emit with no whitespace;
• strings are escaped per RFC 8785 §3.2.2.2 (only required control chars are escaped; Go's default json.Encoder escapes more);
• booleans and nulls emit as `true` / `false` / `null`;
• integers (int, int64, json.Number) emit in base 10 with no leading zeros or `+`.

If the schema ever grows floating-point fields, this will need the ES6 ToString semantics from RFC 8785 §3.2.2.3; that is intentionally out of MVP scope.

func Normalize ¶

func Normalize(format string, raw []byte) (normalized []byte, stripped map[string]any, err error)

Normalize produces the payload bytes that the writer should store when split=true. Each format has its own normalization rules specified in RFC 0001 §Payload Artifact. Unsupported formats return a not-implemented error so the runner can surface it as a per-capture error.

MVP scope: "text", "screenshot", "pdf", and "mhtml" are implemented. "a11y" is blocked on chrest#14 (Chrome SIGTRAP on kernel 6.17) and returns the not-implemented error until that lifts.

func NormalizeStream ¶

func NormalizeStream(format string, src io.Reader) (io.Reader, map[string]any, error)

NormalizeStream is the streaming counterpart to Normalize. It reads the full input into memory, normalizes, and returns a reader plus the stripped map. Normalization is unavoidably buffering for most formats (need to see the whole document), so streaming here is about interface symmetry with StreamCapture rather than memory.