@photivra/engine 2.18.0 → 2.20.0

package/dist/facade/fast-methods.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The registry of every speed-versus-accuracy choice (#395, owner rule of 2.20.0): one entry per choice that has a fast and an
+ * exact (full) method, and per option record that accepts `fast` without a fast method yet. Every entry resolves through
+ * `resolveFast` and `fastFormatDefault` (fast-resolution.ts): an option record's `fast`, else the top-level `fast`, else the
+ * format default (fast for "srgb-8", "srgb-16" and the display view; exact for "dng", "jpeg", "png" and `simulateIdealReference`).
+ *
+ * Data only (a root export, so developers can read which choices exist), read by `test/fast-methods-registry.test.ts`, which
+ * fails when an option accepts `fast` without an entry here, an entry lacks its resolver or its report, or a format's default
+ * leaves the rule. Captures and display views do not import this module (tree-shaking leaves it out of their bundles). A new
+ * fast method adds its entry here and to docs/API_STYLE.md, "Exact and fast modes".
+ * @see docs/API_STYLE.md, "Exact and fast modes".
+ */
+/** One speed-versus-accuracy choice of {@link SIMULATE_CAPTURE_FAST_METHODS} (2.20.0). */
+export interface SimulateCaptureFastMethod {
+    /** A short id: the option path and, where one option has several fast methods, the method. */
+    id: string;
+    /**
+     * The request path whose record takes the `fast` override (`allowKeys` path in simulate-capture.ts), or "fast" when only the
+     * top-level flag sets it (a choice with no option record of its own).
+     */
+    override: string;
+    /** "fast-and-exact": both methods exist; "exact-only": the record takes `fast`, but there is no fast method yet (reports false). */
+    methods: "fast-and-exact" | "exact-only";
+    /** Where it applies. */
+    runs: readonly ("simulateCapture" | "simulateDisplayView" | "prepareDisplayView")[];
+    /** The fast method and the exact one, in words (empty for exact-only). */
+    fast: string;
+    exact: string;
+    /** Always true: no choice keeps its own default (the test checks it). */
+    followsFormatDefault: true;
+    /**
+     * The resolver call in the source (`resolveFast(<record flag>, fastTop)`, or `fastTop` itself for a top-level choice), which the
+     * test finds in the named file.
+     */
+    resolver: {
+        file: string;
+        call: string;
+    };
+    /**
+     * How the result reports it: the `diagnostics.fast.applied` key (true where the fast method ran), an assumption id the fast
+     * method adds, or another result field. At least one; the test finds each assumption id in the source.
+     */
+    report: {
+        applied?: string;
+        assumption?: string;
+        field?: string;
+    };
+}
+/** 2.20.0: every speed-versus-accuracy choice of the capture facade and the display view (see the module comment). */
+export declare const SIMULATE_CAPTURE_FAST_METHODS: readonly SimulateCaptureFastMethod[];

package/dist/facade/fast-methods.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+const CAPTURE = "src/facade/simulate-capture.ts", VIEW = "src/facade/simulate-display-view.ts";
+/** 2.20.0: every speed-versus-accuracy choice of the capture facade and the display view (see the module comment). */
+export const SIMULATE_CAPTURE_FAST_METHODS = /* @__PURE__ */ Object.freeze([
+    { id: "lens.catalogue/field-grid", override: "lens.catalogue", methods: "fast-and-exact", runs: ["simulateCapture"],
+        fast: "#568: the PSF blended over a field grid and tabulated expected electrons, verified per CFA phase against the exact chain",
+        exact: "the environment PSF quadrature with the PSF resolved at each query point", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "resolveFast(catalogueFast, fastTop)" }, report: { applied: "lens.catalogue", assumption: "fast.lens.catalogue" } },
+    { id: "lens.catalogue/cats-eye", override: "lens.catalogue", methods: "fast-and-exact", runs: ["simulateCapture", "simulateDisplayView", "prepareDisplayView"],
+        fast: "#567: with lens.defocus, the lens's bokeh without its cat's eye (the axis kernel everywhere)",
+        exact: "the cat's eye shaped at each field point (fast wides and normals)", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "resolveFast(catalogueFast, fastTop)" }, report: { applied: "lens.catalogue", assumption: "fast.lens.catalogue.catsEye" } },
+    { id: "lens.catalogue/view-psf-zones", override: "lens.catalogue", methods: "fast-and-exact", runs: ["simulateDisplayView", "prepareDisplayView"],
+        fast: "#569 (H1): 64 field zones along the longer side, each with the PSF at its centre",
+        exact: "one zone per site: the PSF at each site centre", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "resolveFast(catalogueFast, fastTop)" }, report: { applied: "lens.catalogue", assumption: "view.lensPsf" } },
+    { id: "lens.diffraction/rolling-shutter-taps", override: "lens.diffraction", methods: "fast-and-exact", runs: ["simulateCapture"],
+        fast: "#565: under rolling-shutter rotation, each PSF tap reads the scene at its own source point",
+        exact: "each tap reads the scene at its site-lattice point (ties on chart boundaries resolve as on the lattice)", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "resolveFast(diffractionFast, fastTop)" }, report: { applied: "lens.diffraction", assumption: "fast.lens.diffraction" } },
+    { id: "output.demosaic.ahd/view-low-signal-correction", override: "output.demosaic", methods: "fast-and-exact", runs: ["simulateDisplayView", "prepareDisplayView"],
+        fast: "(H3) 2048 draws per correction state, applied where a pixel's linear noise exceeds 0.01",
+        exact: "8192 draws per state, at the same 0.01 threshold", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "resolveFast(demosaicFast, fastTop)" }, report: { applied: "output.demosaic.ahd", assumption: "view.demosaic" } },
+    { id: "view.uniform-pixel-sampling", override: "fast", methods: "fast-and-exact", runs: ["simulateDisplayView", "prepareDisplayView"],
+        fast: "(H2) a quarter of the samples per axis in display pixels whose pilot finds no detail",
+        exact: "the full samples per axis in every display pixel", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "uniformSampling: fastTop" }, report: { assumption: "view.estimation" } },
+    { id: "prepareDisplayView.gpu", override: "fast", methods: "fast-and-exact", runs: ["prepareDisplayView"],
+        fast: "gpu \"auto\": WebGPU float32 where a conforming device supports the request (a bounded approximation), else the CPU reference",
+        exact: "gpu \"off\": the CPU reference; an explicit gpu wins", followsFormatDefault: true,
+        resolver: { file: VIEW, call: "parsePrepareDisplayViewOptions(prepareOptions, (options as { fast?: unknown } | null | undefined)?.fast !== false)" },
+        report: { field: "diagnostics.fast.execution" } },
+    { id: "sensor.midGrey", override: "fast", methods: "fast-and-exact", runs: ["simulateCapture", "simulateDisplayView", "prepareDisplayView"],
+        fast: "#535: the mid-gray noise figure is not computed (about 0.3 ms)", exact: "result.sensor.midGrey is computed", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "fastTop ? undefined : 0" }, report: { field: "sensor.midGrey" } },
+    { id: "lens.diffraction", override: "lens.diffraction", methods: "exact-only", runs: ["simulateCapture", "simulateDisplayView", "prepareDisplayView"],
+        fast: "", exact: "the diffraction kernels (a fast method only under rolling-shutter rotation, above)", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "resolveFast(diffractionFast, fastTop)" }, report: { applied: "lens.diffraction" } },
+    { id: "sensor.antiAliasing", override: "sensor.antiAliasing", methods: "exact-only", runs: ["simulateCapture", "simulateDisplayView", "prepareDisplayView"],
+        fast: "", exact: "the point-splitting filter", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "fastInUse" }, report: { applied: "sensor.antiAliasing" } },
+    { id: "sensor.pixelAperture.box", override: "sensor.pixelAperture", methods: "exact-only", runs: ["simulateCapture", "simulateDisplayView", "prepareDisplayView"],
+        fast: "", exact: "the N × N midpoint rule", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "fastInUse" }, report: { applied: "sensor.pixelAperture.box" } },
+    { id: "output.demosaic.ahd", override: "output.demosaic", methods: "exact-only", runs: ["simulateCapture"],
+        fast: "", exact: "the AHD demosaic of the capture (a fast method only in the display view's correction, above)", followsFormatDefault: true,
+        resolver: { file: CAPTURE, call: "resolveFast(demosaicFast, fastTop)" }, report: { applied: "output.demosaic.ahd" } }
+]);
+//# sourceMappingURL=fast-methods.js.map

package/dist/facade/fast-methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fast-methods.js","sourceRoot":"","sources":["../../src/facade/fast-methods.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The registry of every speed-versus-accuracy choice (#395, owner rule of 2.20.0): one entry per choice that has a fast and an\n * exact (full) method, and per option record that accepts `fast` without a fast method yet. Every entry resolves through\n * `resolveFast` and `fastFormatDefault` (fast-resolution.ts): an option record's `fast`, else the top-level `fast`, else the\n * format default (fast for \"srgb-8\", \"srgb-16\" and the display view; exact for \"dng\", \"jpeg\", \"png\" and `simulateIdealReference`).\n *\n * Data only (a root export, so developers can read which choices exist), read by `test/fast-methods-registry.test.ts`, which\n * fails when an option accepts `fast` without an entry here, an entry lacks its resolver or its report, or a format's default\n * leaves the rule. Captures and display views do not import this module (tree-shaking leaves it out of their bundles). A new\n * fast method adds its entry here and to docs/API_STYLE.md, \"Exact and fast modes\".\n * @see docs/API_STYLE.md, \"Exact and fast modes\".\n */\n\n/** One speed-versus-accuracy choice of {@link SIMULATE_CAPTURE_FAST_METHODS} (2.20.0). */\nexport interface SimulateCaptureFastMethod {\n  /** A short id: the option path and, where one option has several fast methods, the method. */\n  id: string;\n  /**\n   * The request path whose record takes the `fast` override (`allowKeys` path in simulate-capture.ts), or \"fast\" when only the\n   * top-level flag sets it (a choice with no option record of its own).\n   */\n  override: string;\n  /** \"fast-and-exact\": both methods exist; \"exact-only\": the record takes `fast`, but there is no fast method yet (reports false). */\n  methods: \"fast-and-exact\" | \"exact-only\";\n  /** Where it applies. */\n  runs: readonly (\"simulateCapture\" | \"simulateDisplayView\" | \"prepareDisplayView\")[];\n  /** The fast method and the exact one, in words (empty for exact-only). */\n  fast: string;\n  exact: string;\n  /** Always true: no choice keeps its own default (the test checks it). */\n  followsFormatDefault: true;\n  /**\n   * The resolver call in the source (`resolveFast(<record flag>, fastTop)`, or `fastTop` itself for a top-level choice), which the\n   * test finds in the named file.\n   */\n  resolver: { file: string; call: string };\n  /**\n   * How the result reports it: the `diagnostics.fast.applied` key (true where the fast method ran), an assumption id the fast\n   * method adds, or another result field. At least one; the test finds each assumption id in the source.\n   */\n  report: { applied?: string; assumption?: string; field?: string };\n}\n\nconst CAPTURE = \"src/facade/simulate-capture.ts\", VIEW = \"src/facade/simulate-display-view.ts\";\n\n/** 2.20.0: every speed-versus-accuracy choice of the capture facade and the display view (see the module comment). */\nexport const SIMULATE_CAPTURE_FAST_METHODS: readonly SimulateCaptureFastMethod[] = /* @__PURE__ */ Object.freeze([\n  { id: \"lens.catalogue/field-grid\", override: \"lens.catalogue\", methods: \"fast-and-exact\", runs: [\"simulateCapture\"],\n    fast: \"#568: the PSF blended over a field grid and tabulated expected electrons, verified per CFA phase against the exact chain\",\n    exact: \"the environment PSF quadrature with the PSF resolved at each query point\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"resolveFast(catalogueFast, fastTop)\" }, report: { applied: \"lens.catalogue\", assumption: \"fast.lens.catalogue\" } },\n  { id: \"lens.catalogue/cats-eye\", override: \"lens.catalogue\", methods: \"fast-and-exact\", runs: [\"simulateCapture\", \"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"#567: with lens.defocus, the lens's bokeh without its cat's eye (the axis kernel everywhere)\",\n    exact: \"the cat's eye shaped at each field point (fast wides and normals)\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"resolveFast(catalogueFast, fastTop)\" }, report: { applied: \"lens.catalogue\", assumption: \"fast.lens.catalogue.catsEye\" } },\n  { id: \"lens.catalogue/view-psf-zones\", override: \"lens.catalogue\", methods: \"fast-and-exact\", runs: [\"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"#569 (H1): 64 field zones along the longer side, each with the PSF at its centre\",\n    exact: \"one zone per site: the PSF at each site centre\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"resolveFast(catalogueFast, fastTop)\" }, report: { applied: \"lens.catalogue\", assumption: \"view.lensPsf\" } },\n  { id: \"lens.diffraction/rolling-shutter-taps\", override: \"lens.diffraction\", methods: \"fast-and-exact\", runs: [\"simulateCapture\"],\n    fast: \"#565: under rolling-shutter rotation, each PSF tap reads the scene at its own source point\",\n    exact: \"each tap reads the scene at its site-lattice point (ties on chart boundaries resolve as on the lattice)\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"resolveFast(diffractionFast, fastTop)\" }, report: { applied: \"lens.diffraction\", assumption: \"fast.lens.diffraction\" } },\n  { id: \"output.demosaic.ahd/view-low-signal-correction\", override: \"output.demosaic\", methods: \"fast-and-exact\", runs: [\"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"(H3) 2048 draws per correction state, applied where a pixel's linear noise exceeds 0.01\",\n    exact: \"8192 draws per state, at the same 0.01 threshold\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"resolveFast(demosaicFast, fastTop)\" }, report: { applied: \"output.demosaic.ahd\", assumption: \"view.demosaic\" } },\n  { id: \"view.uniform-pixel-sampling\", override: \"fast\", methods: \"fast-and-exact\", runs: [\"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"(H2) a quarter of the samples per axis in display pixels whose pilot finds no detail\",\n    exact: \"the full samples per axis in every display pixel\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"uniformSampling: fastTop\" }, report: { assumption: \"view.estimation\" } },\n  { id: \"prepareDisplayView.gpu\", override: \"fast\", methods: \"fast-and-exact\", runs: [\"prepareDisplayView\"],\n    fast: \"gpu \\\"auto\\\": WebGPU float32 where a conforming device supports the request (a bounded approximation), else the CPU reference\",\n    exact: \"gpu \\\"off\\\": the CPU reference; an explicit gpu wins\", followsFormatDefault: true,\n    resolver: { file: VIEW, call: \"parsePrepareDisplayViewOptions(prepareOptions, (options as { fast?: unknown } | null | undefined)?.fast !== false)\" },\n    report: { field: \"diagnostics.fast.execution\" } },\n  { id: \"sensor.midGrey\", override: \"fast\", methods: \"fast-and-exact\", runs: [\"simulateCapture\", \"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"#535: the mid-gray noise figure is not computed (about 0.3 ms)\", exact: \"result.sensor.midGrey is computed\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"fastTop ? undefined : 0\" }, report: { field: \"sensor.midGrey\" } },\n  { id: \"lens.diffraction\", override: \"lens.diffraction\", methods: \"exact-only\", runs: [\"simulateCapture\", \"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"\", exact: \"the diffraction kernels (a fast method only under rolling-shutter rotation, above)\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"resolveFast(diffractionFast, fastTop)\" }, report: { applied: \"lens.diffraction\" } },\n  { id: \"sensor.antiAliasing\", override: \"sensor.antiAliasing\", methods: \"exact-only\", runs: [\"simulateCapture\", \"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"\", exact: \"the point-splitting filter\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"fastInUse\" }, report: { applied: \"sensor.antiAliasing\" } },\n  { id: \"sensor.pixelAperture.box\", override: \"sensor.pixelAperture\", methods: \"exact-only\", runs: [\"simulateCapture\", \"simulateDisplayView\", \"prepareDisplayView\"],\n    fast: \"\", exact: \"the N × N midpoint rule\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"fastInUse\" }, report: { applied: \"sensor.pixelAperture.box\" } },\n  { id: \"output.demosaic.ahd\", override: \"output.demosaic\", methods: \"exact-only\", runs: [\"simulateCapture\"],\n    fast: \"\", exact: \"the AHD demosaic of the capture (a fast method only in the display view's correction, above)\", followsFormatDefault: true,\n    resolver: { file: CAPTURE, call: \"resolveFast(demosaicFast, fastTop)\" }, report: { applied: \"output.demosaic.ahd\" } }\n] as const satisfies readonly SimulateCaptureFastMethod[]);\n"]}

package/dist/facade/fast-resolution.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The one exact-or-fast resolver (#395, 2.20.0) that every speed-versus-accuracy choice of the capture facade and the display
+ * view goes through: an option record's `fast`, else the request's top-level `fast`, else the format default. The registry of
+ * the choices that use it is `fast-methods.ts` (not loaded by captures); docs/API_STYLE.md, "Exact and fast modes".
+ */
+/**
+ * The format default of the top-level `fast` (owner rule, 2.20.0): fast for the sRGB sample formats (`output.format` "srgb-8"
+ * and "srgb-16") and the display view; exact (full quality) for the exports ("dng", "jpeg", "png") and the ideal reference.
+ */
+export declare function fastFormatDefault(format: string, run: "capture" | "display-view" | "ideal-reference"): boolean;
+/** Record `fast` > top-level `fast` (already resolved against {@link fastFormatDefault}). */
+export declare function resolveFast(record: boolean | undefined, top: boolean): boolean;

package/dist/facade/fast-resolution.js

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The one exact-or-fast resolver (#395, 2.20.0) that every speed-versus-accuracy choice of the capture facade and the display
+ * view goes through: an option record's `fast`, else the request's top-level `fast`, else the format default. The registry of
+ * the choices that use it is `fast-methods.ts` (not loaded by captures); docs/API_STYLE.md, "Exact and fast modes".
+ */
+/**
+ * The format default of the top-level `fast` (owner rule, 2.20.0): fast for the sRGB sample formats (`output.format` "srgb-8"
+ * and "srgb-16") and the display view; exact (full quality) for the exports ("dng", "jpeg", "png") and the ideal reference.
+ */
+export function fastFormatDefault(format, run) {
+    return run === "display-view" || run !== "ideal-reference" && format.startsWith("srgb");
+}
+/** Record `fast` > top-level `fast` (already resolved against {@link fastFormatDefault}). */
+export function resolveFast(record, top) {
+    return record ?? top;
+}
+//# sourceMappingURL=fast-resolution.js.map

package/dist/facade/fast-resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fast-resolution.js","sourceRoot":"","sources":["../../src/facade/fast-resolution.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;GAIG;AAEH;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc,EAAE,GAAmD;IACnG,OAAO,GAAG,KAAK,cAAc,IAAI,GAAG,KAAK,iBAAiB,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;AAC1F,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,WAAW,CAAC,MAA2B,EAAE,GAAY;IACnE,OAAO,MAAM,IAAI,GAAG,CAAC;AACvB,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The one exact-or-fast resolver (#395, 2.20.0) that every speed-versus-accuracy choice of the capture facade and the display\n * view goes through: an option record's `fast`, else the request's top-level `fast`, else the format default. The registry of\n * the choices that use it is `fast-methods.ts` (not loaded by captures); docs/API_STYLE.md, \"Exact and fast modes\".\n */\n\n/**\n * The format default of the top-level `fast` (owner rule, 2.20.0): fast for the sRGB sample formats (`output.format` \"srgb-8\"\n * and \"srgb-16\") and the display view; exact (full quality) for the exports (\"dng\", \"jpeg\", \"png\") and the ideal reference.\n */\nexport function fastFormatDefault(format: string, run: \"capture\" | \"display-view\" | \"ideal-reference\"): boolean {\n  return run === \"display-view\" || run !== \"ideal-reference\" && format.startsWith(\"srgb\");\n}\n\n/** Record `fast` > top-level `fast` (already resolved against {@link fastFormatDefault}). */\nexport function resolveFast(record: boolean | undefined, top: boolean): boolean {\n  return record ?? top;\n}\n"]}

package/dist/facade/generic-lens-capture.d.ts

@@ -1,7 +1,10 @@
 /**
  * What `simulateCapture` needs for `lens.catalogue` (#549), loaded on demand: a capture without a catalogue lens (and a bundle
- * that never asks for one) does not load the catalogue's data or its PSF builder.
+ * that never asks for one) does not load the catalogue's data or its PSF builder. It also holds the developed-image lens
+ * corrections (`output.lensCorrections`, #570) and their DNG opcodes (`output.dng.lensCorrectionOpcodes`, #587), which need a catalogue lens.
  */
-export { GENERIC_LENS_EVIDENCE, genericLensDistortionProfile, genericLensVignettingProfile, resolveGenericLens, simulateGenericLensFocusError } from "../equipment/generic-lens-catalogue.js";
-export { createGenericLensPsfProfile, genericLensPsfKernelRadius, GENERIC_LENS_PSF_MAXIMUM_COMBINED_RADIUS_SITES } from "../optics/generic-lens-psf.js";
+export { GENERIC_LENS_EVIDENCE, genericLensDispersion, genericLensDistortionProfile, genericLensVignettingProfile, resolveGenericLens, simulateGenericLensFocusError } from "../equipment/generic-lens-catalogue.js";
+export { createGenericLensPsfProfile, genericLensBokehKernel, genericLensPsfKernelRadius, GENERIC_LENS_PSF_MAXIMUM_COMBINED_RADIUS_SITES } from "../optics/generic-lens-psf.js";
 export { CATALOGUE_FAST_VERIFICATION_TOLERANCE, catalogueFastAssumptions, createCatalogueLensSignal } from "./catalogue-lens-signal.js";
+export { applyDevelopedLensCorrection, developedLensCorrectionSourceRect, prepareDevelopedLensCorrection } from "../output/developed-lens-corrections.js";
+export { createDngLensCorrectionOpcodes } from "../capture/dng-lens-correction-opcodes.js";

package/dist/facade/generic-lens-capture.js

@@ -1,9 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
  * What `simulateCapture` needs for `lens.catalogue` (#549), loaded on demand: a capture without a catalogue lens (and a bundle
- * that never asks for one) does not load the catalogue's data or its PSF builder.
+ * that never asks for one) does not load the catalogue's data or its PSF builder. It also holds the developed-image lens
+ * corrections (`output.lensCorrections`, #570) and their DNG opcodes (`output.dng.lensCorrectionOpcodes`, #587), which need a catalogue lens.
  */
-export { GENERIC_LENS_EVIDENCE, genericLensDistortionProfile, genericLensVignettingProfile, resolveGenericLens, simulateGenericLensFocusError } from "../equipment/generic-lens-catalogue.js";
-export { createGenericLensPsfProfile, genericLensPsfKernelRadius, GENERIC_LENS_PSF_MAXIMUM_COMBINED_RADIUS_SITES } from "../optics/generic-lens-psf.js";
+export { GENERIC_LENS_EVIDENCE, genericLensDispersion, genericLensDistortionProfile, genericLensVignettingProfile, resolveGenericLens, simulateGenericLensFocusError } from "../equipment/generic-lens-catalogue.js";
+export { createGenericLensPsfProfile, genericLensBokehKernel, genericLensPsfKernelRadius, GENERIC_LENS_PSF_MAXIMUM_COMBINED_RADIUS_SITES } from "../optics/generic-lens-psf.js";
 export { CATALOGUE_FAST_VERIFICATION_TOLERANCE, catalogueFastAssumptions, createCatalogueLensSignal } from "./catalogue-lens-signal.js";
+export { applyDevelopedLensCorrection, developedLensCorrectionSourceRect, prepareDevelopedLensCorrection } from "../output/developed-lens-corrections.js";
+export { createDngLensCorrectionOpcodes } from "../capture/dng-lens-correction-opcodes.js";
 //# sourceMappingURL=generic-lens-capture.js.map

package/dist/facade/generic-lens-capture.js.map

@@ -1 +1 @@
-{"version":3,"file":"generic-lens-capture.js","sourceRoot":"","sources":["../../src/facade/generic-lens-capture.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;GAGG;AACH,OAAO,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,MAAM,wCAAwC,CAAC;AAC9L,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,8CAA8C,EAAE,MAAM,+BAA+B,CAAC;AACxJ,OAAO,EAAE,qCAAqC,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What `simulateCapture` needs for `lens.catalogue` (#549), loaded on demand: a capture without a catalogue lens (and a bundle\n * that never asks for one) does not load the catalogue's data or its PSF builder.\n */\nexport { GENERIC_LENS_EVIDENCE, genericLensDistortionProfile, genericLensVignettingProfile, resolveGenericLens, simulateGenericLensFocusError } from \"../equipment/generic-lens-catalogue.js\";\nexport { createGenericLensPsfProfile, genericLensPsfKernelRadius, GENERIC_LENS_PSF_MAXIMUM_COMBINED_RADIUS_SITES } from \"../optics/generic-lens-psf.js\";\nexport { CATALOGUE_FAST_VERIFICATION_TOLERANCE, catalogueFastAssumptions, createCatalogueLensSignal } from \"./catalogue-lens-signal.js\";\n"]}
+{"version":3,"file":"generic-lens-capture.js","sourceRoot":"","sources":["../../src/facade/generic-lens-capture.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;GAIG;AACH,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,MAAM,wCAAwC,CAAC;AACrN,OAAO,EAAE,2BAA2B,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,8CAA8C,EAAE,MAAM,+BAA+B,CAAC;AAChL,OAAO,EAAE,qCAAqC,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACxI,OAAO,EAAE,4BAA4B,EAAE,iCAAiC,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AAC1J,OAAO,EAAE,8BAA8B,EAAE,MAAM,2CAA2C,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What `simulateCapture` needs for `lens.catalogue` (#549), loaded on demand: a capture without a catalogue lens (and a bundle\n * that never asks for one) does not load the catalogue's data or its PSF builder. It also holds the developed-image lens\n * corrections (`output.lensCorrections`, #570) and their DNG opcodes (`output.dng.lensCorrectionOpcodes`, #587), which need a catalogue lens.\n */\nexport { GENERIC_LENS_EVIDENCE, genericLensDispersion, genericLensDistortionProfile, genericLensVignettingProfile, resolveGenericLens, simulateGenericLensFocusError } from \"../equipment/generic-lens-catalogue.js\";\nexport { createGenericLensPsfProfile, genericLensBokehKernel, genericLensPsfKernelRadius, GENERIC_LENS_PSF_MAXIMUM_COMBINED_RADIUS_SITES } from \"../optics/generic-lens-psf.js\";\nexport { CATALOGUE_FAST_VERIFICATION_TOLERANCE, catalogueFastAssumptions, createCatalogueLensSignal } from \"./catalogue-lens-signal.js\";\nexport { applyDevelopedLensCorrection, developedLensCorrectionSourceRect, prepareDevelopedLensCorrection } from \"../output/developed-lens-corrections.js\";\nexport { createDngLensCorrectionOpcodes } from \"../capture/dng-lens-correction-opcodes.js\";\n"]}

package/dist/facade/simulate-capture.d.ts

@@ -25,6 +25,7 @@ import { type DefocusDiscSiteKernel, type ResolvedDefocusDisc } from "../optics/
 import { type DefocusBokehOptions } from "../optics/defocus-bokeh-kernel.js";
 import { type AntiAliasingPointSplitComponent } from "../sensor/optical-stack.js";
 import { type NativeRawDng } from "../capture/native-raw-dng.js";
+import { type SimulateCaptureSensorCharacteristics, type SimulateCaptureSensorReport } from "../sensor/sensor-characteristics.js";
 import { type ChartScene, type ResolvedChartScene } from "./chart-scenes.js";
 import { type ChartMaterialLayerScene, type ResolvedChartMaterialLayers } from "./chart-material-layers.js";
 import { type ChartSizeOption, type CaptureIlluminant, type CallerMaterialScene, type CallerRadianceScene, type CallerReflectanceScene, type ResolvedCallerScene, type PlanarSceneRadianceProvider, type ResolvedCaptureIlluminant } from "./scene-radiance.js";
@@ -157,7 +158,12 @@ export type SimulateCaptureColorEncoding = "srgb" | "display-p3" | "rec2020";
  * edge-directed method that reduces zipper and false colour on sharp edges.
  */
 export type SimulateCaptureDemosaic = "bilinear" | "ahd";
-/** `lens.catalogue` as a record (#568): the lens id as `kind` and the `fast` override (see {@link SimulateCaptureOptions.fast}). */
+/**
+ * `lens.catalogue` as a record (#568): the lens id as `kind` and the `fast` override (see {@link SimulateCaptureOptions.fast}).
+ * Fast: the tabulated fast method (#568), and with `lens.defocus` the lens's bokeh without its cat's eye (#567; fast wides and
+ * normals only), whose field-varying PSF needs a finer fast grid (measured 2.2–3.4× slower). Exact: the per-site PSF with the
+ * cat's eye. Blades and spherical aberration always apply (they cost nothing).
+ */
 export interface SimulateCaptureLensCatalogueRecord {
     kind: string;
     fast?: boolean;
@@ -186,6 +192,11 @@ export type SimulateCaptureLensDistortion = {
  * accepted as a deprecated alias until 3.0.0, and giving both is an error.
  */
 export type SimulateCaptureLensDiffraction = "circular-aperture" | {
+    /**
+     * #565: in focus with camera rotation and `motion.shutter: "rolling"`, exact reads each PSF tap's scene point at its
+     * site-lattice point, as every other path does, so a tap exactly on a chart boundary resolves as on the lattice (about 1.2×
+     * the time); fast keeps each tap's own point, which can resolve such a tie to the other material (docs/QUICK_START.md, "Optics").
+     */
     kind: "circular-aperture";
     kernelRadiusSamples?: number;
     fast?: boolean;
@@ -253,6 +264,18 @@ export interface SimulateCaptureDiffractionCorrection {
     /** FIR radius R in pixels, 1–16. Default: the Airy pattern's third dark ring at the design wavelength, within 1–16. */
     kernelRadiusPixels?: number;
 }
+/**
+ * `output.lensCorrections` (#570): which of the catalogue lens's generic corrections (`createGenericLensCorrectionProfile`) the
+ * development applies. Each is off unless set to true.
+ */
+export interface SimulateCaptureLensCorrections {
+    /** Radial distortion r_d = r(1 + k1ρ²), inverted by resampling: it stretches the corners and lowers their resolution. */
+    distortion?: boolean;
+    /** Lateral colour: each channel rescaled by 1/(1 + L·D(λ_c)) into register; axial (longitudinal) colour stays. */
+    lateralColor?: boolean;
+    /** Vignetting: a gain 1/E(ρ) at each pixel's source point; corner noise rises with the signal, the SNR does not. */
+    vignetting?: boolean;
+}
 /** `diagnostics.detail` (#552): what the development detail stages did. Present only when one ran. */
 export interface SimulateCaptureDetailDiagnostics {
     diffractionCorrection?: {
@@ -314,7 +337,8 @@ export interface SimulateCaptureOptions {
          * distance beyond the focal length (no minimum focus distance; `subjectDistanceM` must be at least twice the focal length, as for
          * every lens). Works in `simulateCapture` and the display view. Not combinable with `prime`, `catalogue` or `focalLengthMm`.
          * Optional `widestFNumber` and `narrowestFNumber` (within `IDEAL_LENS_LIMITS`, widest ≤ narrowest; each defaults to its bound)
-         * narrow the range: `fNumber` must lie in it, and shutter priority and program choose apertures only in it. Default off.
+         * narrow the range: `fNumber` must lie in it, and shutter priority and program choose apertures only in it (program limits its
+         * line to a range that does not hold f/4–f/16, #583). Default off.
          */
         ideal?: {
             focalLengthMm: number;
@@ -327,9 +351,9 @@ export interface SimulateCaptureOptions {
          * factor and it replaces the tier lens's focal length and f-number range (the transmission is kept). The capture renders the
          * lens's character, all labelled approximations: its PSF (diffraction with the lens's Seidel aberrations, axial and lateral
          * colour, at the resolved f-number and focus) through the environment PSF quadrature, its radial distortion, its vignetting
-         * and, for the fisheyes, the equisolid projection. Flare, focus breathing and bokeh shape are not rendered. Not combinable
+         * and, for the fisheyes, the equisolid projection. Flare and focus breathing are not rendered. Not combinable
          * with `prime`, `focalLengthMm`, `projection`, `distortion`, `vignetting`, `psf`, `diffraction` or `pupilSampling` (the
-         * lens sets them); `defocus` convolves the disc into the lens's PSF. The display view renders it with the PSF taken per field zone (#569; docs/DISPLAY_VIEW.md). Default off.
+         * lens sets them); `defocus` convolves the lens's bokeh kernel (#567) into its PSF. The display view renders it with the PSF taken per field zone (#569; docs/DISPLAY_VIEW.md). Default off.
          * #568: the record form `{ kind: <lens id>, fast }` overrides the top-level `fast` flag for this option; the fast method
          * blends the PSF between exactly resolved kernels on a field grid and tabulates each site's expected signal
          * (docs/LENS_CATALOGUE.md, "Fast method").
@@ -485,7 +509,7 @@ export interface SimulateCaptureOptions {
         exposureCompensationStops?: number;
         /** Default "scene-illuminant". */
         whiteBalance?: SimulateCaptureWhiteBalance;
-        /** JPEG constant quantization step 1-255 (not a manufacturer 'quality'). Default 2. */
+        /** JPEG constant quantization step 1-255 (not a manufacturer 'quality'). Default 1 (2.20.0; 2 before), the full-quality export. */
         jpegQuantizationStep?: number;
         /** PNG only. Default "srgb". */
         colorEncoding?: SimulateCaptureColorEncoding;
@@ -500,9 +524,15 @@ export interface SimulateCaptureOptions {
         demosaic?: SimulateCaptureDemosaic | SimulateCaptureDemosaicRecord;
         /** Default "margin". */
         borderHandling?: SimulateCaptureBorderHandling;
-        /** DNG only: optional capture-event time (YYYY-MM-DDTHH:mm:ss.sssZ); without it no date tags are written. */
+        /**
+         * DNG only: optional capture-event time (YYYY-MM-DDTHH:mm:ss.sssZ); without it no date tags are written. Opt-in (#587), with
+         * `lens.catalogue`: `lensCorrectionOpcodes` writes the selected corrections of {@link SimulateCaptureLensCorrections} into the DNG as
+         * optional DNG opcodes in OpcodeList3 (FixVignetteRadial, WarpRectilinear with the zoom-to-fill; docs/NATIVE_RAW_AND_PRINT.md), for RAW editors
+         * that apply them; the RAW codes are unchanged. Whole frame only (no `region`). All off (or omitted): the same DNG bytes as without it.
+         */
         dng?: {
             capturedAtUtc?: string;
+            lensCorrectionOpcodes?: SimulateCaptureLensCorrections;
         };
         /**
          * Opt-in (2.4) text written into the file for formats "jpeg", "png" and "dng": the caller's description,
@@ -547,10 +577,21 @@ export interface SimulateCaptureOptions {
          * (not the wide-gamut or perceptual PNG paths); not combinable with `region`. The DNG's RAW codes are not changed. Default off.
          */
         sharpening?: SimulateCaptureSharpening;
+        /**
+         * Opt-in (#570), with `lens.catalogue`: the lens's generic corrections (see {@link SimulateCaptureLensCorrections}) on the
+         * developed linear colour, after demosaic, colour, white balance and `diffractionCorrection`, before the tone curve; for the JPEG,
+         * PNG and samples. The RAW and the DNG are never corrected. To keep the output size with no missing pixels, the corrected image is
+         * magnified by the smallest factor 1/m ≥ 1 that keeps every pixel's source inside the frame (recorded in the
+         * `output.lensCorrections` assumption). Works with `region`: a region develops the frame pixels its corrected pixels read
+         * (`region.nativeRect`, `raw` and `plan` describe that rectangle) and its pixels are the whole render's. All off (or omitted):
+         * the development is unchanged.
+         */
+        lensCorrections?: SimulateCaptureLensCorrections;
     };
     /** Camera motion and shutter type. Default: still camera, global electronic shutter. */
     motion?: SimulateCaptureMotion;
-    sensor?: {
+    /** #555: plus the sensor characteristics ({@link SimulateCaptureSensorCharacteristics}), each off by default. */
+    sensor?: SimulateCaptureSensorCharacteristics & {
         /**
          * Pixel pitch in micrometres, 0.5–1000. Default 6. The simulated sensor is output width × pitch wide. 2.5: above 100 µm the
          * capture is a downsized view of a whole frame (for example 36 mm / 48 pixels = 750 µm), recorded in the assumption
@@ -577,22 +618,26 @@ export interface SimulateCaptureOptions {
         pixelAperture?: SimulateCapturePixelAperture;
     };
     /**
-     * Exact or fast (#395). `false` or omitted: every option runs its exact method, the engine reference. `true`: each option
-     * listed in {@link SIMULATE_CAPTURE_FAST_OPTIONS} runs its fast method where it has one, a measured, bounded approximation of
-     * the exact one; an option without a fast method runs exact. An option's own record `fast` overrides this for that option
-     * only. `diagnostics.fast` reports what was requested and what ran. `lens.catalogue` has a fast method (#568); the other options run exact.
+     * Exact or fast (#395). `false`: every option runs its exact method, the engine reference. `true`: each option listed in
+     * {@link SIMULATE_CAPTURE_FAST_OPTIONS} runs its fast method where it has one, a measured, bounded approximation of the exact
+     * one; an option without a fast method runs exact. An option's own record `fast` overrides this for that option only.
+     * Omitted (2.20.0), the format decides: fast for `output.format` "srgb-8" and "srgb-16" and for the display view, exact for
+     * "dng", "jpeg" and "png" (exports) and for `simulateIdealReference`. `diagnostics.fast` reports the resolved value, where it
+     * came from and what ran. Fast methods: `lens.catalogue` (#568, #567) and `lens.diffraction` under rolling-shutter rotation
+     * (#565); in the display view also its catalogue PSF zones, its sampling of uniform pixels and its AHD low-signal correction
+     * (docs/DISPLAY_VIEW.md). The exact result also carries `result.sensor.midGrey` (#535). Calculators should pass `fast: false`.
      */
     fast?: boolean;
     /** Aborting cancels the running task; the promise rejects with a domain error and returns no partial image. */
     signal?: AbortSignal;
-    /** Called after each committed RAW, development or JPEG tile. Cannot change output. */
+    /** Called after each committed RAW, development, detail or JPEG tile (see {@link SimulateCaptureProgress}). Cannot change output. */
     onProgress?: (progress: SimulateCaptureProgress) => void;
 }
 /**
  * Options reported in `diagnostics.options` (2.1), in this order, when they ran: the ones that change how much work
  * a capture does. `motion.rotation` is a non-zero angular velocity; `sensor.temporalSampleCount` a count above 1.
  */
-export declare const SIMULATE_CAPTURE_COST_OPTIONS: readonly ["lens.pupilSampling", "lens.projection", "lens.distortion", "lens.vignetting", "lens.psf", "lens.diffraction", "lens.defocus", "lens.catalogue", "sensor.antiAliasing", "sensor.pixelAperture.box", "sensor.temporalSampleCount", "motion.rotation", "motion.shutter.rolling", "output.borderHandling.mirror", "output.region", "output.whiteBalance.auto", "output.demosaic.ahd", "output.highlightMode.reconstruct", "output.colorEncoding.wide-gamut", "output.gamutMapping.perceptual", "output.diffractionCorrection", "output.sharpening", "output.format.jpeg", "output.format.png", "output.format.dng"];
+export declare const SIMULATE_CAPTURE_COST_OPTIONS: readonly ["lens.pupilSampling", "lens.projection", "lens.distortion", "lens.vignetting", "lens.psf", "lens.diffraction", "lens.defocus", "lens.catalogue", "sensor.antiAliasing", "sensor.pixelAperture.box", "sensor.temporalSampleCount", "motion.rotation", "motion.shutter.rolling", "output.borderHandling.mirror", "output.region", "output.whiteBalance.auto", "output.demosaic.ahd", "output.highlightMode.reconstruct", "output.colorEncoding.wide-gamut", "output.gamutMapping.perceptual", "output.diffractionCorrection", "output.sharpening", "output.lensCorrections", "output.format.jpeg", "output.format.png", "output.format.dng"];
 export type SimulateCaptureCostOption = typeof SIMULATE_CAPTURE_COST_OPTIONS[number];
 /**
  * The options that take the exact-or-fast flag (#395), in the path style of {@link SIMULATE_CAPTURE_COST_OPTIONS}: each accepts
@@ -603,15 +648,24 @@ export declare const SIMULATE_CAPTURE_FAST_OPTIONS: readonly ["lens.diffraction"
 export type SimulateCaptureFastOption = typeof SIMULATE_CAPTURE_FAST_OPTIONS[number];
 /** `diagnostics.fast` of a capture or display view (#395): what was asked for and what ran. */
 export interface SimulateCaptureFastReport {
-    /** True when `fast: true` was given at the top level or in any option's record. */
+    /** 2.20.0: the resolved top-level value (`fast`, else the format default), or true when any option's record sets `fast: true`. */
     requested: boolean;
+    /** 2.20.0: where the top-level value came from: the request's `fast`, or the format default (see {@link SimulateCaptureOptions.fast}). */
+    defaultedFrom: "request" | "format";
     /** Each fast-capable option that ran, in {@link SIMULATE_CAPTURE_FAST_OPTIONS} order: true where its fast method ran. */
     applied: Readonly<Partial<Record<SimulateCaptureFastOption, boolean>>>;
     /** `engine-reference` when every option ran exact; `approximation-with-a-priori-bound` when any fast method ran (the WebGPU execution record's values). */
     assurance: "engine-reference" | "approximation-with-a-priori-bound";
 }
+/**
+ * One progress event of `onProgress`. Stages run in this order: `raw`, `white-balance` (with auto white balance), `development`
+ * (rows), then, when requested, `diffraction-correction` and `sharpening` (#571: one event per output row of the whole image;
+ * each stage's last event has `completedTileCount === totalTileCount`), then `jpeg`. `output.lensCorrections` (#570) runs between
+ * `diffraction-correction` and `sharpening` and reports no stage of its own. {@link simulateCaptureFromParts}
+ * reports no `raw` stage: its RAW comes from the parts.
+ */
 export interface SimulateCaptureProgress {
-    stage: "raw" | "white-balance" | "development" | "jpeg";
+    stage: "raw" | "white-balance" | "development" | "diffraction-correction" | "sharpening" | "jpeg";
     completedTileCount: number;
     totalTileCount: number;
 }
@@ -823,6 +877,8 @@ export interface SimulateCaptureResult {
         limitations: readonly string[];
     };
     assumptions: readonly SimulateCaptureAssumption[];
+    /** #555, #535: the sensor characteristics used, the calculated dynamic range and (when the request resolves to exact) the mid-grey noise figure. */
+    sensor: SimulateCaptureSensorReport;
 }
 export declare const FACADE_EVIDENCE: readonly EvidenceProvenance[];
 /**
@@ -872,6 +928,12 @@ export interface SimulateCaptureDngPart {
             height: number;
         };
     };
+    /**
+     * 2.20.0: true when a fast method ran for this part (`Object.values(result.diagnostics.fast.applied).includes(true)`). The join
+     * refuses such a part unless its own request resolves to fast too (a DNG, JPEG or PNG is exact by default): render the parts with
+     * the same `fast` as the join, or with `fast: false`.
+     */
+    fast?: boolean;
 }
 /**
  * Writes the whole-frame DNG of `options` (`output.format: "dng"`, no `output.region`) from the packed RAW of region renders of
@@ -1026,6 +1088,8 @@ export interface DisplayViewResult {
         autoIso?: SimulateCaptureAutoIsoReport;
     };
     scene: SimulateCaptureResult["scene"];
+    /** #555, #535: as in the capture result. */
+    sensor: SimulateCaptureSensorReport;
     /**
      * Work done: real pixels sampled, real-site expectations evaluated, scene queries, display pixels sampled in full (detail) or with
      * a quarter of the samples per axis (uniform), display pixels whose value includes the AHD low-signal correction, and wall-clock
@@ -1164,6 +1228,12 @@ export interface DisplayViewRunContext {
         readoutProfile: ReadoutProfile;
         regimeId: string;
     }>;
+    sensor: SimulateCaptureSensorReport;
+    /** 2.20.0: the view's own fast methods, resolved: the AHD low-signal correction's draws and threshold (`output.demosaic.ahd`) and the quarter sampling of uniform pixels (top-level `fast`). */
+    viewFast: {
+        ahd: boolean;
+        uniformSampling: boolean;
+    };
     resolvedIso: number;
     /** #516: how the ISO was chosen, reported in the view's `exposure`. */
     isoReport: {
@@ -1214,11 +1284,13 @@ export interface ParsedDisplayView {
 export declare function parseDisplayViewOption(value: unknown, frameWidth: number, frameHeight: number): ParsedDisplayView;
 /** Internal: passed as the view of a "display-view" run to resolve the request without a view (`prepareDisplayView`, #387). */
 export declare const DISPLAY_VIEW_WITHOUT_VIEW: unique symbol;
+/** Internal: what `runCapture` produces. The two `-from-parts` runs take the parts as `viewOption`. */
+type CaptureRun = "capture" | "ideal-reference" | "display-view" | "dng-from-parts" | "develop-from-parts";
 /**
  * Internal: the request path shared by {@link simulateCapture}, {@link simulateIdealReference} and the display view, whose renderer is
  * passed in; for a display view the renderer's value is returned (a result, or a prepared view with DISPLAY_VIEW_WITHOUT_VIEW).
  */
-export declare function runCapture(options: SimulateCaptureOptions, run: "capture" | "ideal-reference" | "display-view" | "dng-from-parts", viewOption?: unknown, renderView?: (context: DisplayViewRunContext) => Promise<unknown>): Promise<unknown>;
+export declare function runCapture(options: SimulateCaptureOptions, run: CaptureRun, viewOption?: unknown, renderView?: (context: DisplayViewRunContext) => Promise<unknown>): Promise<unknown>;
 /** Chart preset ids accepted by `simulateCapture({ scene: { preset } })`. */
 export declare const SIMULATE_CAPTURE_CHART_PRESETS: readonly ("composite" | "uniform" | "patches" | "slanted-edge" | "siemens-star" | "step-wedge" | "grey-ramp" | "checkerboard" | "point-grid" | "color-patches" | "dead-leaves" | "bar-groups" | "hyperbolic-wedge" | "zone-plate" | "slanted-squares" | "line-grid" | "fiducial")[];
 export {};