@poe-platform/safe-bash 0.1.806 → 0.1.807

package/third-party/spreadsheet-engine/scripts/harfbuzz/completion.patch

@@ -0,0 +1,98 @@
+--- a/src/hb-buffer.cc
++++ b/src/hb-buffer.cc
+@@ -341,6 +341,9 @@
+ void
+ hb_buffer_t::leave ()
+ {
++  /* Preserve exhausted work before leave resets the counters. */
++  if (unlikely (max_ops <= 0))
++    successful = false;
+   max_len = HB_BUFFER_MAX_LEN_DEFAULT;
+   max_ops = HB_BUFFER_MAX_OPS_DEFAULT;
+   deallocate_var_all ();
+--- a/src/hb-shape.cc
++++ b/src/hb-shape.cc
+@@ -131,7 +131,7 @@
+ 	       const char * const *shaper_list)
+ {
+   if (unlikely (!buffer->len))
+-    return true;
++    return buffer->successful;
+ 
+   buffer->enter ();
+ 
+@@ -166,7 +166,7 @@
+ 
+   buffer->leave ();
+ 
+-  return res;
++  return res && buffer->successful;
+ }
+ 
+ /**
+--- a/src/hb-sanitize.hh
++++ b/src/hb-sanitize.hh
+@@ -119,6 +119,9 @@
+ #ifndef HB_SANITIZE_MAX_SUBTABLES
+ #define HB_SANITIZE_MAX_SUBTABLES 0x4000
+ #endif
++
++/* Owned build completion signal; no partial sanitized table is published. */
++extern "C" void ssconvert_hb_resource_failure (unsigned kind);
+ 
+ struct hb_sanitize_context_t :
+        hb_dispatch_context_t<hb_sanitize_context_t, bool, HB_DEBUG_SANITIZE>
+@@ -148,6 +151,8 @@
+   bool visit_subtables (unsigned count)
+   {
+     max_subtables += count;
++    if (unlikely (max_subtables >= HB_SANITIZE_MAX_SUBTABLES))
++      ssconvert_hb_resource_failure (2);
+     return max_subtables < HB_SANITIZE_MAX_SUBTABLES;
+   }
+ 
+@@ -250,6 +255,8 @@
+ 
+   void end_processing ()
+   {
++    if (unlikely (max_ops <= 0))
++      ssconvert_hb_resource_failure (1);
+     DEBUG_MSG_LEVEL (SANITIZE, this->start, 0, -1,
+ 		     "end [%p..%p]",
+ 		     this->start, this->end);
+@@ -266,6 +273,7 @@
+     if (unlikely (this->max_ops < 0 || count >= (unsigned) this->max_ops))
+     {
+       this->max_ops = -1;
++      ssconvert_hb_resource_failure (1);
+       return false;
+     }
+     this->max_ops -= (int) count;
+@@ -280,8 +288,12 @@
+   {
+     const char *p = (const char *) base;
+     bool ok = (uintptr_t) (p - this->start) <= this->length &&
+-	      (unsigned int) (this->end - p) >= len &&
+-	      ((this->max_ops -= len) > 0);
++	      (unsigned int) (this->end - p) >= len;
++    if (ok && (this->max_ops -= len) <= 0)
++    {
++      ssconvert_hb_resource_failure (1);
++      ok = false;
++    }
+ 
+     DEBUG_MSG_LEVEL (SANITIZE, p, this->debug_depth+1, 0,
+ 		     "check_range [%p..%p]"
+@@ -381,7 +393,11 @@
+ 
+   bool check_start_recursion (int max_depth)
+   {
+-    if (unlikely (recursion_depth >= max_depth)) return false;
++    if (unlikely (recursion_depth >= max_depth))
++    {
++      ssconvert_hb_resource_failure (3);
++      return false;
++    }
+     return ++recursion_depth;
+   }
+ 

package/third-party/spreadsheet-engine/scripts/harfbuzz/config-override.h

@@ -0,0 +1,19 @@
+#undef HB_NO_CFF
+#undef HB_NO_OT_FONT_CFF
+#undef HB_NO_DRAW
+#undef HB_NO_PAINT
+#undef HB_NO_COLOR
+#undef HB_NO_BUFFER_MESSAGE
+#undef HB_NO_BUFFER_SERIALIZE
+#undef HB_NO_VAR
+#undef HB_NO_OT_FONT_GLYPH_NAMES
+#undef HB_NO_FACE_COLLECT_UNICODES
+#undef HB_NO_AVAR2
+#undef HB_NO_CUBIC_GLYF
+#undef HB_NO_VAR_COMPOSITES
+#undef HB_NO_NAME
+#undef HB_NO_METRICS
+#undef HB_NO_LAYOUT_FEATURE_PARAMS
+#undef HB_NO_LAYOUT_RARELY_USED
+#undef HB_NO_LAYOUT_UNUSED
+#define HB_BUFFER_MESSAGE_MORE 1

package/third-party/spreadsheet-engine/scripts/harfbuzz/exports.json

@@ -0,0 +1,29 @@
+[
+  "_malloc",
+  "_free",
+  "_hb_blob_create",
+  "_hb_blob_destroy",
+  "_hb_face_create",
+  "_hb_face_destroy",
+  "_hb_face_get_upem",
+  "_hb_font_create",
+  "_hb_font_destroy",
+  "_hb_font_set_scale",
+  "_hb_buffer_create",
+  "_hb_buffer_destroy",
+  "_hb_buffer_add_utf16",
+  "_hb_buffer_guess_segment_properties",
+  "_hb_buffer_get_length",
+  "_hb_buffer_get_glyph_infos",
+  "_hb_buffer_get_glyph_positions",
+  "_hb_buffer_get_content_type",
+  "_hb_buffer_allocation_successful",
+  "_hb_shape_full",
+  "_hb_version_string",
+  "_ssconvert_hb_failure",
+  "_hb_buffer_set_cluster_level",
+  "_hb_buffer_get_direction",
+  "_hb_buffer_get_script",
+  "_hb_buffer_get_language",
+  "_hb_language_to_string"
+]

package/third-party/spreadsheet-engine/scripts/harfbuzz/sources.json

@@ -0,0 +1,274 @@
+{
+  "schema": 1,
+  "upstream": {
+    "name": "HarfBuzz",
+    "version": "14.5.0",
+    "commit": "863d3f7787c6df18d20e4535c5906bf3eb803bd5",
+    "url": "https://codeload.github.com/harfbuzz/harfbuzz/tar.gz/863d3f7787c6df18d20e4535c5906bf3eb803bd5",
+    "archiveSha256": "35d6211b9310646c8d6b7c06d697439efd26d787ec8fff2508e6b936836ca492",
+    "sourceFiles": 575,
+    "sourceTreeSha256": "af236e8d32c86fab9ae6925beaf90500b9f158a17d95259f3f77b3c3ecb54e12",
+    "treeEncoding": "SHA-256 of JSON array [relative path, byte length, SHA-256] sorted by UTF-16 path comparison"
+  },
+  "toolchain": {
+    "emscripten": "4.0.13",
+    "emscriptenCommit": "2659582941bef14008476903f48941909db1b196",
+    "versionLine": "emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 4.0.13 (2659582941bef14008476903f48941909db1b196)",
+    "emsdkCommit": "404dc1ec13f64fce1af1eaf5c007e18212f63527",
+    "recipeRepository": "https://github.com/harfbuzz/harfbuzzjs",
+    "recipeCommit": "b2ec00c97159ee8aa563691792aa3081adbc8a50"
+  },
+  "compilerFlags": [
+    "-DNDEBUG",
+    "-DHB_NO_BUFFER_VERIFY",
+    "-DHB_NO_ERRNO",
+    "-DHB_NO_OPEN",
+    "-DHB_NO_MMAP",
+    "-DHB_NO_GETENV",
+    "-DHB_NO_SETLOCALE",
+    "-DHB_NO_MT",
+    "-DHB_NO_ATEXIT",
+    "-std=c++11",
+    "-fno-exceptions",
+    "-fno-rtti",
+    "-fno-threadsafe-statics",
+    "-fvisibility-inlines-hidden",
+    "-Oz",
+    "-flto",
+    "-DHB_USE_INTERNAL_QSORT",
+    "-DHB_EXPERIMENTAL_API",
+    "-DHB_CUSTOM_MALLOC",
+    "-DHB_CONFIG_OVERRIDE_H=\"config-override.h\"",
+    "--no-entry",
+    "-sMODULARIZE",
+    "-sEXPORT_ES6",
+    "-sEXPORT_NAME=createHarfBuzz",
+    "-sINITIAL_MEMORY=256KB",
+    "-sALLOW_MEMORY_GROWTH",
+    "-sALLOW_TABLE_GROWTH",
+    "-lexports.js"
+  ],
+  "patches": [
+    {
+      "path": "hb-buffer.cc",
+      "beforeSha256": "58bd6aa7a3e93d21fe02041c53d9de7dea9e9cbc6d1826583ebff42952539245",
+      "afterSha256": "5b28a252cc82ccf31f638a260844404a1912763f22d75481d6a6325cd63fef83"
+    },
+    {
+      "path": "hb-shape.cc",
+      "beforeSha256": "2825723cfe9e101c93fd39adce889be2990751416babab4b16f8e36c1cb2bf6c",
+      "afterSha256": "bb9b74458d988a845d35c6d48480d5ea1c12114bba89e088ef7e367d3c9e737c"
+    },
+    {
+      "path": "hb-sanitize.hh",
+      "beforeSha256": "84bab23aa0035d9720fe0a7c384cb9d7898520967c4e91d34edcafb2363286df",
+      "afterSha256": "45bd5483a5b199ff334961505e3e9be642afe96323d97991bcb544a794921374"
+    }
+  ],
+  "inputs": [
+    {
+      "path": "packages/spreadsheet-engine/scripts/harfbuzz/allocator.cc",
+      "sha256": "1ce6466e6076047929d96116808ff5633e733a3a792dbf752c49cfdd470fe57e"
+    },
+    {
+      "path": "packages/spreadsheet-engine/scripts/harfbuzz/completion.patch",
+      "sha256": "8f5a72341053e9af2286e85ca6e94f158fc90e2b536b645f862dd2e12efb7501"
+    },
+    {
+      "path": "packages/spreadsheet-engine/scripts/harfbuzz/config-override.h",
+      "sha256": "8ddfba91f84d10530f2bf00934172a0adc8c0a3c38720022505d2d02a8be261d"
+    },
+    {
+      "path": "packages/spreadsheet-engine/scripts/harfbuzz/exports.json",
+      "sha256": "7d20b616c63dd4773f0740e00a54aa27b7c6d14f156cff80f935d3aee8e351a0"
+    },
+    {
+      "path": "packages/spreadsheet-engine/src/rendering/print/harfbuzz/NOTICE.md",
+      "sha256": "942994c8af79eca0897d964e42539d15e9fe803e65af66b467e7d451acbc0e64"
+    },
+    {
+      "path": "packages/spreadsheet-engine/src/rendering/print/harfbuzz/HARFBUZZ-LICENSE.txt",
+      "sha256": "ba8f810f2455c2f08e2d56bb49b72f37fcf68f1f4fade38977cfd7372050ad64"
+    },
+    {
+      "path": "packages/spreadsheet-engine/src/rendering/print/harfbuzz/EMSCRIPTEN-LICENSE.txt",
+      "sha256": "620a78084fc7ca97c0b5dea9abf891f3ffcadfdbf305276f099c9c4e12fc1d86"
+    },
+    {
+      "path": "packages/spreadsheet-engine/src/rendering/print/harfbuzz/MUSL-LICENSE.txt",
+      "sha256": "f9bc4423732350eb0b3f7ed7e91d530298476f8fec0c6c427a1c04ade22655af"
+    },
+    {
+      "path": "packages/spreadsheet-engine/src/rendering/print/harfbuzz/LIBCXX-LICENSE.txt",
+      "sha256": "539dd7aed86e8a4f12cbdd0e6c50c189c7d74847e4fecc64ce2c6ee3a01da38b"
+    },
+    {
+      "path": "packages/spreadsheet-engine/src/rendering/print/harfbuzz/LIBCXXABI-LICENSE.txt",
+      "sha256": "e2b35be49f7284a45b7baca8fc7b3ab7440e7902392b2528a457816b5bb2a15c"
+    }
+  ],
+  "artifact": {
+    "path": "packages/spreadsheet-engine/src/rendering/print/harfbuzz/data.ts",
+    "exportName": "harfbuzzBase64",
+    "bytes": 553970,
+    "sha256": "68569480a0b76c81040de1e8b5d441317d479ea07a629bc0ce75bbd0ac7c0258",
+    "initialMemoryBytes": 262144,
+    "maximumMemoryBytes": 2147483648,
+    "imports": [
+      {
+        "module": "wasi_snapshot_preview1",
+        "name": "proc_exit",
+        "kind": "function"
+      },
+      {
+        "module": "env",
+        "name": "_emscripten_runtime_keepalive_clear",
+        "kind": "function"
+      },
+      {
+        "module": "env",
+        "name": "_abort_js",
+        "kind": "function"
+      },
+      {
+        "module": "env",
+        "name": "_setitimer_js",
+        "kind": "function"
+      },
+      {
+        "module": "env",
+        "name": "emscripten_resize_heap",
+        "kind": "function"
+      }
+    ],
+    "exports": [
+      {
+        "name": "memory",
+        "kind": "memory"
+      },
+      {
+        "name": "__wasm_call_ctors",
+        "kind": "function"
+      },
+      {
+        "name": "hb_blob_create",
+        "kind": "function"
+      },
+      {
+        "name": "hb_blob_destroy",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_create",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_destroy",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_get_content_type",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_get_direction",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_get_script",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_get_language",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_set_cluster_level",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_allocation_successful",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_get_length",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_get_glyph_infos",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_get_glyph_positions",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_guess_segment_properties",
+        "kind": "function"
+      },
+      {
+        "name": "hb_buffer_add_utf16",
+        "kind": "function"
+      },
+      {
+        "name": "hb_language_to_string",
+        "kind": "function"
+      },
+      {
+        "name": "hb_version_string",
+        "kind": "function"
+      },
+      {
+        "name": "hb_face_create",
+        "kind": "function"
+      },
+      {
+        "name": "hb_face_destroy",
+        "kind": "function"
+      },
+      {
+        "name": "hb_face_get_upem",
+        "kind": "function"
+      },
+      {
+        "name": "hb_font_create",
+        "kind": "function"
+      },
+      {
+        "name": "hb_font_destroy",
+        "kind": "function"
+      },
+      {
+        "name": "hb_font_set_scale",
+        "kind": "function"
+      },
+      {
+        "name": "hb_shape_full",
+        "kind": "function"
+      },
+      {
+        "name": "malloc",
+        "kind": "function"
+      },
+      {
+        "name": "free",
+        "kind": "function"
+      },
+      {
+        "name": "ssconvert_hb_failure",
+        "kind": "function"
+      },
+      {
+        "name": "_emscripten_timeout",
+        "kind": "function"
+      }
+    ]
+  },
+  "failureBits": {
+    "allocator": 1,
+    "buffer": 2,
+    "sanitizerWork": 4,
+    "sanitizerSubtables": 8,
+    "sanitizerRecursion": 16
+  }
+}

package/third-party/spreadsheet-engine/scripts/harfbuzz/verify.d.mts

@@ -0,0 +1,10 @@
+export function verifyArtifact(input: {
+  source: string;
+  manifest: unknown;
+  files: ReadonlyMap<string, Uint8Array>;
+}): {
+  byteLength: number;
+  initialMemoryBytes: number;
+  maximumMemoryBytes: number;
+  sha256: string;
+};

package/third-party/spreadsheet-engine/scripts/harfbuzz/verify.mjs

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import {createHash} from "node:crypto";
+import {lstatSync, readFileSync} from "node:fs";
+import {resolve} from "node:path";
+import {fileURLToPath} from "node:url";
+import ts from "typescript";
+
+const repository = fileURLToPath(new URL("../../../../", import.meta.url));
+const sourcePath = "packages/spreadsheet-engine/src/rendering/print/harfbuzz/data.ts";
+const allowedRoots = ["packages/spreadsheet-engine/src/rendering/print/harfbuzz/", "packages/spreadsheet-engine/scripts/harfbuzz/"];
+const digest = bytes => createHash("sha256").update(bytes).digest("hex");
+
+function inputPath(path) {
+  assert.equal(typeof path, "string", "invalid input path");
+  assert.ok(allowedRoots.some(root => path.startsWith(root)) && !path.includes("\\") &&
+    path.split("/").every(part => part && part !== "." && part !== ".."), "invalid input path");
+  return resolve(repository, path);
+}
+
+function memoryLimits(bytes) {
+  let offset = 8;
+  const integer = () => {
+    let value = 0;
+    for (let shift = 0; shift < 35; shift += 7) {
+      assert.ok(offset < bytes.length, "truncated memory metadata");
+      const byte = bytes[offset++];
+      value += (byte & 127) * 2 ** shift;
+      if (!(byte & 128)) return value;
+    }
+    throw new Error("invalid memory metadata");
+  };
+  while (offset < bytes.length) {
+    const section = bytes[offset++], size = integer(), end = offset + size;
+    assert.ok(end <= bytes.length, "invalid memory section bounds");
+    if (section === 5) {
+      assert.equal(integer(), 1, "expected one memory");
+      assert.equal(integer(), 1, "expected bounded, nonshared wasm32 memory");
+      const initialMemoryBytes = integer() * 65536, maximumMemoryBytes = integer() * 65536;
+      assert.equal(offset, end, "unexpected memory section data");
+      return {initialMemoryBytes, maximumMemoryBytes};
+    }
+    offset = end;
+  }
+  throw new Error("missing memory section");
+}
+
+export function verifyArtifact({source, manifest, files}) {
+  assert.equal(manifest.schema, 1, "unsupported source manifest");
+  const tree = ts.createSourceFile(sourcePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  assert.equal(tree.parseDiagnostics.length, 0, "invalid generated source");
+  assert.equal(tree.statements.length, 1, "expected a single exported string");
+  const statement = tree.statements[0];
+  assert.ok(ts.isVariableStatement(statement) && statement.modifiers?.length === 1 &&
+    statement.modifiers[0].kind === ts.SyntaxKind.ExportKeyword &&
+    (statement.declarationList.flags & ts.NodeFlags.Const) && statement.declarationList.declarations.length === 1,
+  "expected a single exported string");
+  const declaration = statement.declarationList.declarations[0];
+  assert.ok(ts.isIdentifier(declaration.name) && declaration.name.text === "harfbuzzBase64" &&
+    declaration.initializer && ts.isStringLiteral(declaration.initializer), "expected harfbuzzBase64 string literal");
+  const encoded = declaration.initializer.text;
+  assert.ok(declaration.initializer.getText(tree) === JSON.stringify(encoded), "expected canonical base64 literal");
+  const bytes = Buffer.from(encoded, "base64");
+  assert.ok(bytes.toString("base64") === encoded, "invalid base64 encoding");
+  assert.equal(bytes.length, manifest.artifact.bytes, "artifact byte length mismatch");
+  assert.equal(digest(bytes), manifest.artifact.sha256, "artifact digest mismatch");
+  const module = new WebAssembly.Module(bytes);
+  assert.deepEqual(WebAssembly.Module.imports(module), manifest.artifact.imports, "artifact imports mismatch");
+  assert.deepEqual(WebAssembly.Module.exports(module), manifest.artifact.exports, "artifact exports mismatch");
+  const memory = memoryLimits(bytes);
+  assert.equal(memory.initialMemoryBytes, manifest.artifact.initialMemoryBytes, "initial memory mismatch");
+  assert.equal(memory.maximumMemoryBytes, manifest.artifact.maximumMemoryBytes, "maximum memory mismatch");
+  const paths = new Set();
+  for (const input of manifest.inputs) {
+    inputPath(input.path);
+    assert.ok(!paths.has(input.path), "duplicate input path");
+    paths.add(input.path);
+    const value = files.get(input.path);
+    assert.ok(value instanceof Uint8Array, `missing input: ${input.path}`);
+    assert.equal(digest(value), input.sha256, `input digest mismatch: ${input.path}`);
+  }
+  return {byteLength: bytes.length, ...memory, sha256: manifest.artifact.sha256};
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const manifest = JSON.parse(readFileSync(new URL("sources.json", import.meta.url), "utf8"));
+  const files = new Map();
+  for (const input of manifest.inputs) {
+    const path = inputPath(input.path);
+    assert.ok(lstatSync(path).isFile(), `input is not a regular file: ${input.path}`);
+    files.set(input.path, readFileSync(path));
+  }
+  const source = inputPath(sourcePath);
+  assert.ok(lstatSync(source).isFile(), "generated source is not a regular file");
+  const result = verifyArtifact({source: readFileSync(source, "utf8"), manifest, files});
+  process.stdout.write(`Verified HarfBuzz ${manifest.upstream.version}: ${result.byteLength} bytes, ${result.sha256}\n`);
+}

package/third-party/spreadsheet-engine/scripts/harfbuzz/verify.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import {readFileSync} from "node:fs";
+import {test} from "node:test";
+import {verifyArtifact} from "./verify.mjs";
+
+const repository = new URL("../../../../", import.meta.url);
+const manifest = JSON.parse(readFileSync(new URL("sources.json", import.meta.url), "utf8"));
+const source = readFileSync(new URL("../../src/rendering/print/harfbuzz/data.ts", import.meta.url), "utf8");
+const files = new Map(manifest.inputs.map(input => [input.path, readFileSync(new URL(input.path, repository))]));
+const verify = (changes = {}) => verifyArtifact({source, manifest, files, ...changes});
+
+test("authenticates the portable artifact and its build inputs", () => {
+  const result = verify();
+  assert.equal(result.byteLength, 553970);
+  assert.equal(result.initialMemoryBytes, 262144);
+  assert.equal(result.maximumMemoryBytes, 2147483648);
+});
+
+test("refuses executable or ambiguous generated source", () => {
+  assert.throws(() => verify({source: source + "\nthrow new Error('injected');\n"}), /single exported string/);
+  assert.throws(() => verify({source: source.replace('= "', '= String("').replace('";\n', '");\n')}), /string literal/);
+});
+
+test("refuses malformed base64 and changed binary bytes", () => {
+  assert.throws(() => verify({source: source.replace('= "', '= "!')}), /base64/);
+  const corrupt = source.replace('AGFzbQ', 'BGFzbQ');
+  assert.notEqual(corrupt, source);
+  assert.throws(() => verify({source: corrupt}), /digest/);
+});
+
+test("refuses a changed import or an unexpected export", () => {
+  const changedImport = structuredClone(manifest);
+  changedImport.artifact.imports[0].name = "fd_write";
+  assert.throws(() => verify({manifest: changedImport}), /imports/);
+  const changedExport = structuredClone(manifest);
+  changedExport.artifact.exports.push({name: "review_install_fault", kind: "function"});
+  assert.throws(() => verify({manifest: changedExport}), /exports/);
+});
+
+test("refuses changed memory limits", () => {
+  const changed = structuredClone(manifest);
+  changed.artifact.maximumMemoryBytes = 65536;
+  assert.throws(() => verify({manifest: changed}), /memory/);
+});
+
+test("refuses missing or altered source and license bindings", () => {
+  for (const entry of manifest.inputs) {
+    const changed = new Map(files);
+    changed.set(entry.path, Buffer.from("altered"));
+    assert.throws(() => verify({files: changed}), /input digest/);
+    changed.delete(entry.path);
+    assert.throws(() => verify({files: changed}), /missing input/);
+  }
+});
+
+test("refuses paths outside the owned asset and maintenance directories", () => {
+  const changed = structuredClone(manifest);
+  changed.inputs[0].path = "../../private";
+  assert.throws(() => verify({manifest: changed}), /input path/);
+});

package/third-party/spreadsheet-engine/src/rendering/images/NOTICE.md

@@ -0,0 +1,22 @@
+Graph export admission, anchor ordering, target identity and failure behavior
+implement reviewed Gnumeric 1.12.61 and GOffice 0.10.61 behavior. The exact
+archives, source-member hashes, native dependency/plugin/locale profile, measured
+coverage and remaining mismatches are recorded in
+`docs/ssconvert/graph-image-exports-verification.json`. See the package LICENSE
+and original upstream source headers.
+
+Behavioral sources include Gnumeric `src/ssconvert.c` (Copyright 2002-2003 Jody
+Goldberg; 2006-2018 Morten Welinder), `src/sheet-object.c`,
+`src/sheet-object-graph.c`, `src/xml-sax-read.c`, GOffice
+`goffice/utils/go-image.c` (Copyright 2004-2005 Jody Goldberg),
+`goffice/graph/gog-renderer.c` (Copyright 2003-2004 Jody Goldberg), and
+`goffice/graph/gog-graph.c`.
+
+PNG, PDF, PostScript/EPS, BMP, ICO and TIFF encoders emit their declared image
+formats in JavaScript. JPEG uses the portable encoder from @poe-code/image-ast.
+Native utilities
+are QA oracles only. Metafile targets preserve the pinned native unsupported
+save outcome. The built-in graph scene producer supports genuinely empty graphs
+and explicitly configured opaque solid backgrounds with disabled outlines;
+plot scenes and other paints need an injected JavaScript scene producer. This is an
+explicit remaining implementation gap, not native unsupported-target parity.

package/third-party/spreadsheet-engine/src/rendering/print/NOTICE.md

@@ -0,0 +1,30 @@
+# Print geometry source notice
+
+The pagination and fit algorithms follow released Gnumeric 1.12.61
+`src/print.c` (compute_group, adjust_repetition, paginate,
+compute_scale_fit_to, compute_sheet_pages and print_page), with source
+authors Miguel de Icaza, Morten Welinder and Andreas J. Guelzow; copyright
+2007 Andreas J. Guelzow and 2007–2009 Morten Welinder. Gnumeric is
+GPL-2.0-or-later; these TypeScript
+implementations are distributed under this package's GPL-2.0-or-later license.
+See the package LICENSE for license terms.
+
+The official source archive SHA-256 is
+`2ac135d856572713c1a408b76b50a59f2a9769ed21f1213446b5af255df20a12`.
+Authenticated `src/print.c` SHA-256 is
+`fee11181a89822062f3dac39fde3734e554338fae5237e0ce9e96114882da71b`.
+Source acquisition/extraction stays under out. No native executable, font data,
+source archive or discovery capability is part of these geometry helpers.
+
+The helpers require explicit geometry and invocation budgets/cancellation.
+They do not supply workbook selection, font shaping, painting or PDF rendering.
+
+Header/footer opcode parsing follows `src/print-info.c`
+(`gnm_print_hf_format_render`, `render_opcode` and the render callbacks),
+authors Andreas J. Guelzow, Jody Goldberg and Miguel de Icaza; copyright
+2007–2009 Morten Welinder, under GPL-2.0-or-later. Authenticated source SHA-256 is
+`ff970d578a151d5e7a76ed962cb3e9159383c6a992cd9ce85d2c0d998a349e11`.
+The helper takes explicit filename/path/sheet/title/page metadata; date formatting
+and cell resolution are injected. It does not discover ambient time, locale or
+filesystem state, and its English opcode support is not a translated opcode
+catalog or native collation implementation.