@honua/app-platform 0.1.2-beta.0 → 0.1.7-beta.0

package/web-components/export.d.ts

@@ -0,0 +1,417 @@
+/**
+ * The Honua component kit's **export-adapter contract** (issue #683, parent
+ * epic #678; REQ-001/REQ-002/REQ-003).
+ *
+ * ## Why an adapter at all
+ *
+ * `<honua-print-export>` has always offered three actions — print layout,
+ * renderer snapshot, sanitized state JSON — but only browser print was ever
+ * implemented. The other two were *correctly* reported as unsupported rather
+ * than being faked, because producing them safely needs something the
+ * component kit does not have and must not guess at:
+ *
+ * - A **renderer** it is allowed to read pixels from. `canvas.toDataURL()` on a
+ *   WebGL map silently returns a blank image unless the map was created with
+ *   `canvasContextAttributes: { preserveDrawingBuffer: true }` (MapLibre 5 and
+ *   6; earlier majors took a top-level `preserveDrawingBuffer`), and it throws on a canvas tainted by
+ *   cross-origin tiles. Only the application that constructed the map knows
+ *   which of those is true, and only it can decide whether reading those
+ *   pixels is authorized.
+ * - An **authorization boundary**. A map's live state transitively references
+ *   the credentials that made it work: signed tile URLs, `Authorization`
+ *   headers, SAS query strings, OAuth scope detail. Serializing "the current
+ *   state" naively hands all of that to whoever receives the file.
+ *
+ * So export is modelled as an explicit, injected capability. There is no
+ * ambient fallback that "does its best": with no adapter, snapshot and state
+ * export **fail closed** with {@link HonuaCapabilityNotSupportedError} and
+ * produce no bytes at all. That is the whole point — a missing adapter must
+ * never degrade into a silent, partially-credentialed artifact.
+ *
+ * ## The four things the contract makes explicit (REQ-001)
+ *
+ * 1. **Capability** — {@link HonuaExportAdapter.describeCapabilities} declares
+ *    exactly which kinds the adapter implements. A kind it does not declare is
+ *    refused before the adapter is called; a kind it declares but does not
+ *    implement is a *reported* contract violation, never a silent no-op.
+ * 2. **Ownership** — every result carries {@link HonuaExportResult.ownership}
+ *    and an always-present {@link HonuaExportResult.release}. `bytes` handed to
+ *    the caller are the caller's to keep and remain valid after `release()`;
+ *    `release()` frees only adapter-held resources (object URLs, offscreen
+ *    canvases, server-side render jobs). Callers can therefore always call it
+ *    exactly once, unconditionally, in a `finally`.
+ * 3. **Cancellation** — an {@link AbortSignal} is checked before the adapter
+ *    runs, forwarded to it, and re-checked after it returns; a cancelled export
+ *    releases whatever the adapter produced and yields `status: "cancelled"`
+ *    with no bytes.
+ * 4. **Error reporting** — the runner never throws. It returns a discriminated
+ *    {@link HonuaExportResult} whose `status` is one of
+ *    `ready`/`unsupported`/`cancelled`/`error`, with a redacted `message` and
+ *    the structured `error` for programmatic handling. Elements can render the
+ *    envelope directly; callers who prefer exceptions use
+ *    {@link assertHonuaExportReady}.
+ *
+ * ## Redaction is not the adapter's job (REQ-002)
+ *
+ * The runner sanitizes state **before** the adapter is invoked, so an adapter
+ * — including a third-party or server-side one — never receives credential
+ * material in the first place. It then re-scans everything the adapter returned
+ * (bytes, text, filename hint, fidelity warnings) and refuses to emit an
+ * artifact that fails the scan. Both layers live in
+ * {@link "./export-redaction.js"}; see that module for the two-layer model.
+ *
+ * ## Provenance travels with the artifact (REQ-003)
+ *
+ * Attribution, license notices, scale, export timestamp, data-freshness, and
+ * fidelity warnings are assembled by the runner from the map package and
+ * controller state, handed to the adapter, and echoed on the result. Where a
+ * source declares attribution, the export **cannot** drop it: an artifact
+ * missing required attribution fails closed exactly like a credential leak,
+ * because shipping an unattributed map is a licence violation, not a cosmetic
+ * defect.
+ *
+ * ## Bundle posture (NFR-001)
+ *
+ * This module and its redaction sibling import nothing but the SDK's own error
+ * base and types. No renderer, PDF writer, image encoder, localization
+ * framework, or test-only peer is referenced, statically or dynamically —
+ * every one of those lives on the application side of the adapter seam. The
+ * built-in adapters here are thin structural shims over objects the caller
+ * already owns.
+ *
+ * @module
+ */
+import { HonuaSdkError } from "../core/error-envelope.js";
+import { type HonuaExportRedaction, type HonuaSanitizedExportState } from "./export-redaction.js";
+import type { HonuaViewportState, HonuaWebComponentState } from "./types.js";
+/** What an export produces. */
+export type HonuaExportKind = 
+/** A print layout (browser print dialog, or an adapter-rendered paginated document). */
+"print"
+/** A raster/vector image of the current renderer view. */
+ | "snapshot"
+/** A sanitized, credential-free JSON document describing the current view state. */
+ | "state";
+/** Every export kind, in a stable order. */
+export declare const HONUA_EXPORT_KINDS: readonly HonuaExportKind[];
+/** Terminal status of one export attempt. */
+export type HonuaExportStatus = 
+/** An artifact was produced and passed every safety assertion. */
+"ready"
+/** No adapter, or the adapter does not implement this kind. No bytes were produced. */
+ | "unsupported"
+/** The caller's `AbortSignal` fired. Adapter-held resources were released. */
+ | "cancelled"
+/** The adapter threw, returned an unusable payload, or produced an unsafe artifact. */
+ | "error";
+/** Who is responsible for releasing adapter-held resources. */
+export type HonuaExportOwnership = 
+/** Nothing to release; `release()` is a no-op. */
+"none"
+/** The caller must call `release()` when finished; the runner has not called it. */
+ | "caller-releases"
+/** The runner already released everything (cancelled/failed export). */
+ | "released";
+/**
+ * Attribution and fidelity metadata that must survive into every artifact
+ * (REQ-003). Assembled by {@link buildHonuaExportProvenance}.
+ */
+export interface HonuaExportProvenance {
+    /** ISO-8601 instant the export was produced. */
+    readonly exportedAt: string;
+    /** Attribution strings required by the bound sources or the accepted plan. Never dropped. */
+    readonly attribution: readonly string[];
+    /** Licence notices required by the bound sources or the accepted plan. Never dropped. */
+    readonly licenseNotices: readonly string[];
+    /** Human-readable approximate scale, e.g. `"1:24,000"`. */
+    readonly scaleLabel?: string;
+    /** ISO-8601 instant the underlying data was last refreshed, when known. */
+    readonly dataFreshnessAt?: string;
+    /** `true` when the exported view is known to be showing stale data. */
+    readonly stale?: boolean;
+    /**
+     * Honest statements about what the artifact does *not* faithfully reproduce
+     * (unsupported layer types, omitted non-exportable sources, rasterized
+     * vector text, ...). Adapters may append their own.
+     */
+    readonly fidelityWarnings: readonly string[];
+    /** Map-package id the export came from, when known. */
+    readonly packageId?: string;
+    /** The producing component kit, for artifact traceability. */
+    readonly generator: string;
+}
+/** Declares what an adapter can actually do. */
+export interface HonuaExportCapabilities {
+    /** Stable adapter id, surfaced on results and in diagnostics. */
+    readonly adapterId: string;
+    /** Kinds this adapter implements. A kind absent here is refused before the adapter runs. */
+    readonly kinds: readonly HonuaExportKind[];
+    /** Whether the adapter honours an `AbortSignal` mid-flight. Purely informational: the runner enforces cancellation either way. */
+    readonly cancellable: boolean;
+    /** Media types the adapter can emit for `snapshot`, most preferred first. */
+    readonly snapshotMediaTypes?: readonly string[];
+    /** Optional pixel ceiling the adapter will not exceed, for callers sizing a request. */
+    readonly maxSnapshotPixels?: number;
+}
+/**
+ * Everything an adapter is given. Note what is *absent*: no controller, no
+ * client, no credential store, no raw state. An adapter cannot reach
+ * credential material through this object even if it tries.
+ */
+export interface HonuaExportContext {
+    readonly kind: HonuaExportKind;
+    /** Caller-supplied, already-redacted title. */
+    readonly title: string | undefined;
+    /** Provenance the adapter must stamp into the artifact where the format allows it. */
+    readonly provenance: HonuaExportProvenance;
+    /** Credential-free state document. Always present for `state`; supplied for the others as layout input. */
+    readonly state: HonuaSanitizedExportState;
+    /** Cancellation signal. Adapters that do long work should honour it. */
+    readonly signal: AbortSignal | undefined;
+    /** Requested media type, when the caller expressed a preference. */
+    readonly mediaType: string | undefined;
+}
+/** What an adapter returns for a successful export. */
+export interface HonuaExportPayload {
+    /** Media type of `bytes`/`text`. */
+    readonly mediaType: string;
+    /** Binary artifact. Mutually exclusive with `text` in practice; `bytes` wins if both are set. */
+    readonly bytes?: Uint8Array;
+    /** Text artifact (JSON, SVG, HTML). */
+    readonly text?: string;
+    /** Suggested filename stem. Sanitized by the runner; a hint that looks credential-bearing is discarded. */
+    readonly filenameHint?: string;
+    /** Additional honest fidelity caveats, merged into the result's provenance. */
+    readonly fidelityWarnings?: readonly string[];
+    /**
+     * Releases adapter-held resources. The runner always calls this exactly once
+     * on a cancelled or failed export, and never calls it on a successful one —
+     * a successful result hands the obligation to the caller via
+     * {@link HonuaExportResult.release}.
+     */
+    readonly release?: () => void | Promise<void>;
+    /**
+     * `true` when this export completed as a side effect and carries no bytes —
+     * the browser print dialog being the canonical case.
+     */
+    readonly sideEffectOnly?: boolean;
+    /**
+     * Whether the artifact's **bytes** carry the attribution and licence notices
+     * the sources require (REQ-003) — a watermark composited into the image, a
+     * PDF footer, a JSON provenance block.
+     *
+     * Defaults to `false`, which is the honest default: reading a WebGL canvas
+     * captures the map's pixels and nothing else, because MapLibre renders its
+     * attribution as DOM outside the canvas. An adapter that does not composite
+     * attribution must not claim it did, so the runner adds an explicit fidelity
+     * warning naming what the caller has to present alongside the artifact, and
+     * {@link HonuaExportRequest.requireEmbeddedProvenance} turns that into a hard
+     * failure for callers who cannot.
+     */
+    readonly provenanceEmbedded?: boolean;
+}
+/**
+ * One export kind's implementation. Every method is optional; whichever kinds
+ * {@link HonuaExportAdapter.describeCapabilities} declares must have the
+ * matching method, and the runner reports a violation rather than silently
+ * succeeding when it does not.
+ */
+export interface HonuaExportAdapter {
+    /** Stable identifier, echoed on results. */
+    readonly id: string;
+    describeCapabilities(): HonuaExportCapabilities;
+    print?(context: HonuaExportContext): HonuaExportPayload | Promise<HonuaExportPayload>;
+    snapshot?(context: HonuaExportContext): HonuaExportPayload | Promise<HonuaExportPayload>;
+    exportState?(context: HonuaExportContext): HonuaExportPayload | Promise<HonuaExportPayload>;
+}
+/** The outcome of one export attempt. Never thrown — always returned. */
+export interface HonuaExportResult {
+    readonly kind: HonuaExportKind;
+    readonly status: HonuaExportStatus;
+    /** Adapter that served the request, or `undefined` when none was available. */
+    readonly adapterId: string | undefined;
+    /** Credential-safe download filename. Present only on `ready`. */
+    readonly filename?: string;
+    readonly mediaType?: string;
+    /** Caller-owned bytes. Remain valid after {@link release}. */
+    readonly bytes?: Uint8Array;
+    /** Caller-owned text. */
+    readonly text?: string;
+    /** `true` when the export completed as a side effect (browser print) and has no payload. */
+    readonly sideEffectOnly?: boolean;
+    readonly provenance: HonuaExportProvenance;
+    /**
+     * Whether the required attribution and licence notices are carried by the
+     * artifact's own bytes (REQ-003). When `false`, `provenance` still names them
+     * and `provenance.fidelityWarnings` says so explicitly — the caller is
+     * responsible for presenting them wherever the artifact is published.
+     * `undefined` only on results that produced no artifact.
+     */
+    readonly provenanceEmbedded?: boolean;
+    /** Everything withheld while sanitizing state for this export. */
+    readonly redactions: readonly HonuaExportRedaction[];
+    readonly ownership: HonuaExportOwnership;
+    /** Always defined; safe to call exactly once regardless of `status`. Idempotent. */
+    readonly release: () => Promise<void>;
+    /** Redacted, human-readable explanation. Safe to log, display, or put on an event. */
+    readonly message?: string;
+    /** Structured failure for programmatic handling. */
+    readonly error?: HonuaSdkError;
+}
+export interface HonuaExportRequest<T = Record<string, unknown>> {
+    readonly kind: HonuaExportKind;
+    /** Adapter to serve the request. Omitting it is what makes an export fail closed. */
+    readonly adapter?: HonuaExportAdapter | undefined;
+    /** Live component state. Sanitized before the adapter sees any of it. */
+    readonly state?: HonuaWebComponentState<T> | undefined;
+    /** Untrusted title (map name, package id, user input). */
+    readonly title?: string;
+    readonly signal?: AbortSignal;
+    readonly mediaType?: string;
+    /** Sources the accepted plan marks non-exportable. See `SanitizeHonuaExportStateOptions`. */
+    readonly nonExportableSourceIds?: readonly string[];
+    /** Extra attribution required by the accepted plan beyond what the sources declare. */
+    readonly requiredAttribution?: readonly string[];
+    /** Licence notices required by the accepted plan. */
+    readonly requiredLicenseNotices?: readonly string[];
+    /**
+     * Fail closed unless the adapter embeds the required attribution into the
+     * artifact's own bytes (REQ-003). Off by default, because the common and
+     * legitimate arrangement is for the application to present attribution
+     * alongside the artifact — the result reports
+     * {@link HonuaExportResult.provenanceEmbedded} and carries an explicit
+     * fidelity warning either way. Set this when the artifact will travel on its
+     * own, with no surrounding surface to carry the notice.
+     */
+    readonly requireEmbeddedProvenance?: boolean;
+    /** Overrides the export timestamp. Tests pin it; production should not set it. */
+    readonly exportedAt?: string;
+}
+/** Thrown by {@link assertHonuaExportReady} and used to wrap adapter faults. */
+export declare class HonuaExportError extends HonuaSdkError {
+    readonly status: HonuaExportStatus;
+    constructor(status: Exclude<HonuaExportStatus, "ready">, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** `1:24,000`-style approximate scale for a web-mercator viewport at 96 DPI. */
+export declare function approximateHonuaScaleLabel(viewport: HonuaViewportState | undefined): string | undefined;
+export interface BuildHonuaExportProvenanceOptions {
+    readonly requiredAttribution?: readonly string[];
+    readonly requiredLicenseNotices?: readonly string[];
+    readonly fidelityWarnings?: readonly string[];
+    readonly exportedAt?: string;
+}
+/**
+ * Assembles the provenance block for an export (REQ-003) from the map package
+ * and controller state, unioned with anything the accepted plan additionally
+ * requires. Every string is redacted, because attribution text is
+ * caller-supplied and has appeared with a signed URL in it in the wild.
+ */
+export declare function buildHonuaExportProvenance<T>(state: HonuaWebComponentState<T> | undefined, sanitized: HonuaSanitizedExportState, options?: BuildHonuaExportProvenanceOptions): HonuaExportProvenance;
+/**
+ * Fail-closed provenance check (REQ-003): every attribution string and licence
+ * notice a source or the accepted plan declares must be present on the
+ * provenance that ships with the artifact.
+ *
+ * This exists because provenance is the one part of an export a well-meaning
+ * adapter or caller is most likely to "simplify away". Dropping attribution is
+ * a licence breach, so it is enforced with the same severity as a credential
+ * leak rather than logged as a warning.
+ */
+export declare function assertHonuaExportProvenanceComplete(provenance: HonuaExportProvenance, required: {
+    readonly attribution: readonly string[];
+    readonly licenseNotices: readonly string[];
+}): void;
+/**
+ * Runs one export end to end. Never throws: every failure mode — no adapter,
+ * undeclared kind, missing method, adapter exception, cancellation, unsafe
+ * artifact, missing provenance — comes back as a {@link HonuaExportResult}.
+ *
+ * @example Fail closed with no adapter
+ * ```ts doc-test=skip reason="illustrative excerpt over an ambient controller state"
+ * const result = await runHonuaExport({ kind: "snapshot", state });
+ * result.status;        // "unsupported"
+ * result.bytes;         // undefined — no partial artifact is ever produced
+ * result.error?.sdkCode // "core.capability-not-supported"
+ * ```
+ */
+export declare function runHonuaExport<T>(request: HonuaExportRequest<T>): Promise<HonuaExportResult>;
+/** Throws `result.error` unless the export succeeded; returns the result otherwise. */
+export declare function assertHonuaExportReady(result: HonuaExportResult): HonuaExportResult;
+/** The minimal renderer surface a snapshot adapter needs. Structurally satisfied by a MapLibre `Map`'s canvas. */
+export interface HonuaSnapshotCanvasLike {
+    toDataURL?(type?: string, quality?: number): string;
+    toBlob?(callback: (blob: unknown) => void, type?: string, quality?: number): void;
+}
+/** What {@link createHonuaExportAdapter} needs to serve a snapshot. */
+export interface HonuaSnapshotSource {
+    /**
+     * Returns the renderer canvas to read pixels from, or `undefined` when the
+     * renderer is not currently readable. Returning `undefined` makes the
+     * snapshot fail closed instead of emitting a blank image.
+     *
+     * The application is asserting, by supplying this, that the canvas was
+     * created with `canvasContextAttributes: { preserveDrawingBuffer: true }`
+     * (or is otherwise readable) and that reading it is authorized.
+     */
+    getCanvas(): HonuaSnapshotCanvasLike | undefined;
+    /** Preferred media type, default `image/png`. */
+    readonly mediaType?: string;
+    /** Fidelity caveats the application knows apply to its snapshots. */
+    readonly fidelityWarnings?: readonly string[];
+    /**
+     * Set only if `getCanvas()` returns a canvas that already has the required
+     * attribution composited into its pixels (an application that draws a
+     * watermark or footer before handing the canvas over). Left `false`, the
+     * export reports honestly that the bytes do not carry attribution.
+     */
+    readonly provenanceEmbedded?: boolean;
+}
+export interface CreateHonuaExportAdapterOptions {
+    readonly id: string;
+    /** Supply to enable `snapshot`. Omit and the adapter simply does not declare that kind. */
+    readonly snapshot?: HonuaSnapshotSource;
+    /** Supply to enable `print`. `createBrowserPrintExportAdapter()` covers the browser-dialog case. */
+    readonly print?: (context: HonuaExportContext) => HonuaExportPayload | Promise<HonuaExportPayload>;
+    /**
+     * Enables the sanitized-state export. `true` uses the runner's own
+     * credential-free JSON projection; a function lets the application wrap it
+     * (adding its own envelope) while still starting from the sanitized document.
+     */
+    readonly state?: boolean | ((context: HonuaExportContext) => HonuaExportPayload | Promise<HonuaExportPayload>);
+}
+/**
+ * Builds an export adapter from capabilities the application explicitly grants.
+ *
+ * Everything here is structural: no `maplibre-gl`, `cesium`, PDF writer, or
+ * image encoder is imported, so wiring an adapter costs a consumer bundle
+ * nothing beyond the object it passes in (NFR-001).
+ *
+ * @example
+ * ```ts doc-test=skip reason="requires a live MapLibre map instance"
+ * const adapter = createHonuaExportAdapter({
+ *   id: "my-app",
+ *   // map created with canvasContextAttributes: { preserveDrawingBuffer: true }
+ *   snapshot: { getCanvas: () => map.getCanvas() },
+ *   state: true,
+ * });
+ * printExportElement.exportAdapter = adapter;
+ * ```
+ */
+export declare function createHonuaExportAdapter(options: CreateHonuaExportAdapterOptions): HonuaExportAdapter;
+/** The window surface {@link createBrowserPrintExportAdapter} needs. */
+export interface HonuaPrintWindowLike {
+    print(): void;
+}
+/**
+ * The browser-print adapter: the one export the component kit can serve without
+ * application help, because `window.print()` reads no pixels and serializes no
+ * state — the browser prints what it already renders, under the user's own
+ * session.
+ *
+ * It is a *default* for `print` only. Snapshot and state export deliberately
+ * have no equivalent built-in, because both require reading privileged data.
+ */
+export declare function createBrowserPrintExportAdapter(windowLike?: HonuaPrintWindowLike | undefined): HonuaExportAdapter;
+//# sourceMappingURL=export.d.ts.map

package/web-components/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../src/web-components/export.ts"],"names":[],"mappings":"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"}