@opengeni/artifact-tool 0.2.2

package/dist/materializer-cli-entry.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/materializer-cli-entry.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import {
+  runArtifactMaterializerCli
+} from "./chunk-NAG44K67.js";
+import "./chunk-DCTLTNPW.js";
+import "./chunk-U5G2BKM2.js";
+import "./chunk-ZCJYRJGB.js";
+import "./chunk-B2ZJRZDA.js";
+import "./chunk-J6N7IR44.js";
+import "./chunk-IYFXZQ34.js";
+import "./chunk-4FRFNNBM.js";
+import "./chunk-O24KTEGP.js";
+import "./chunk-N2IHNWBS.js";
+import "./chunk-72SYDU4O.js";
+import "./chunk-FGZM4FQ6.js";
+import "./chunk-4BSENMAE.js";
+import "./chunk-Q2FFHEY7.js";
+import "./chunk-VUNV25KB.js";
+
+// src/materializer-cli-entry.ts
+try {
+  await runArtifactMaterializerCli(process.argv.slice(2));
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${JSON.stringify({ error: { code: "materializer_failed", message } })}
+`);
+  process.exitCode = 1;
+}
+//# sourceMappingURL=materializer-cli-entry.js.map

package/dist/materializer-cli-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/materializer-cli-entry.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { runArtifactMaterializerCli } from \"./materializer-cli\";\n\ntry {\n  await runArtifactMaterializerCli(process.argv.slice(2));\n} catch (error) {\n  const message = error instanceof Error ? error.message : String(error);\n  process.stderr.write(`${JSON.stringify({ error: { code: \"materializer_failed\", message } })}\\n`);\n  process.exitCode = 1;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAIA,IAAI;AACF,QAAM,2BAA2B,QAAQ,KAAK,MAAM,CAAC,CAAC;AACxD,SAAS,OAAO;AACd,QAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,UAAQ,OAAO,MAAM,GAAG,KAAK,UAAU,EAAE,OAAO,EAAE,MAAM,uBAAuB,QAAQ,EAAE,CAAC,CAAC;AAAA,CAAI;AAC/F,UAAQ,WAAW;AACrB;","names":[]}

package/dist/materializer-cli.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import type { ArtifactKernelRuntime } from "./runtime.js";
+declare const XLSX_CODEC_ID = "opengeni.xlsx";
+export type EditableArtifactNativeMaterializerCapabilities = Readonly<{
+    protocol: "OGAMC001";
+    runtimeKind: "native";
+    runtimeTarget: string;
+    kernelVersion: string;
+    codecVersions: Readonly<Record<typeof XLSX_CODEC_ID, string>>;
+    fontRegistryHash: string;
+    policyHash: string;
+    maxOutputBytes: number;
+    supportedModelSchemaVersions: readonly [1];
+    supportedOperationProtocolVersions: readonly [1];
+    supportedSnapshotProtocolVersions: readonly [1];
+}>;
+export declare function runArtifactMaterializerCli(args: readonly string[], environment?: Readonly<Record<string, string | undefined>>): Promise<void>;
+/**
+ * Exact producer profile derived from the same verified native runtime used by
+ * the materializer child. The API uses this rather than accepting job identity
+ * facts from clients.
+ */
+export declare function editableArtifactMaterializerCapabilitiesForRuntime(runtime: ArtifactKernelRuntime, packageVersion: string): EditableArtifactNativeMaterializerCapabilities;
+export {};

package/dist/materializer-cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  editableArtifactMaterializerCapabilitiesForRuntime,
+  runArtifactMaterializerCli
+} from "./chunk-NAG44K67.js";
+import "./chunk-DCTLTNPW.js";
+import "./chunk-U5G2BKM2.js";
+import "./chunk-ZCJYRJGB.js";
+import "./chunk-B2ZJRZDA.js";
+import "./chunk-J6N7IR44.js";
+import "./chunk-IYFXZQ34.js";
+import "./chunk-4FRFNNBM.js";
+import "./chunk-O24KTEGP.js";
+import "./chunk-N2IHNWBS.js";
+import "./chunk-72SYDU4O.js";
+import "./chunk-FGZM4FQ6.js";
+import "./chunk-4BSENMAE.js";
+import "./chunk-Q2FFHEY7.js";
+import "./chunk-VUNV25KB.js";
+export {
+  editableArtifactMaterializerCapabilitiesForRuntime,
+  runArtifactMaterializerCli
+};
+//# sourceMappingURL=materializer-cli.js.map

package/dist/materializer-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/native-raster.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Rasterize with an explicit font authority when the host configures one.
+ * Resvg otherwise succeeds while silently dropping every glyph on minimal
+ * Linux images. Sandboxes pin regular/bold/italic-capable Liberation faces;
+ * desktop installs retain their native system-font fallback.
+ */
+export declare function rasterizeSvgToPng(svg: string, options?: Readonly<{
+    background?: string;
+    zoom?: number;
+}>): Promise<Uint8Array>;

package/dist/native.d.ts

@@ -0,0 +1,129 @@
+import { type EditableArtifactMutationIntent, type SpreadsheetArtifactCommandBatch } from "@opengeni/contracts/editable-artifacts";
+import { ArtifactKernelRuntime, type ArtifactKernelCapabilities, type NativeArtifactRuntimeTarget } from "./runtime.js";
+export { SPREADSHEET_ARTIFACT_COMMAND_VERSION, assertCanonicalSpreadsheetArtifactCommandBytes, decodeSpreadsheetArtifactCommandBatch, editableArtifactStableId, encodeSpreadsheetArtifactCommandBatch, spreadsheetSheetId, } from "@opengeni/contracts/editable-artifacts";
+export type { EditableArtifactStableId, SpreadsheetArtifactCommand, SpreadsheetArtifactCommandBatch, SpreadsheetCellInput, SpreadsheetCellPoint, SpreadsheetCellRange, SpreadsheetSheetGeneration, SpreadsheetSheetPrecondition, } from "@opengeni/contracts/editable-artifacts";
+export type NativeArtifactModality = "spreadsheet" | "document" | "presentation";
+export type NativeSpreadsheetIntentFields = Omit<EditableArtifactMutationIntent, "envelopeVersion" | "protocolVersion" | "modelSchemaVersion" | "commandProtocolVersion" | "commandBytes">;
+export type NativeSpreadsheetAuthorCommandsInput = Readonly<{
+    intent: NativeSpreadsheetIntentFields;
+    commands: SpreadsheetArtifactCommandBatch;
+    /** Exact authoritative OGACF001 base selected for this apply attempt. */
+    resolvedBaseBytes: Uint8Array;
+}>;
+export type NativeSpreadsheetAuthoredTransaction = Readonly<{
+    /** Exact canonical OGATX001 bytes passed to Rust. */
+    intentBytes: Uint8Array;
+    requestHash: string;
+    /** One whole canonical OGACO001 transaction returned by Rust. */
+    committedTransactionBytes: Uint8Array;
+}>;
+export type CreateNativeArtifactSessionInput = Readonly<{
+    modality: NativeArtifactModality;
+    replicaNamespace: bigint;
+}>;
+export type OpenNativeArtifactSessionInput = Readonly<{
+    modality: NativeArtifactModality;
+    snapshot: Uint8Array;
+}>;
+export type NativeArtifactSession = NativeSpreadsheetSession | NativeDocumentSession | NativePresentationSession;
+/**
+ * Synchronous Node/Bun production spreadsheet session backed only by the
+ * verified Rust N-API collaboration kernel. It never selects the TypeScript
+ * reference model and deliberately rejects a browser/WASM runtime; browsers
+ * use the asynchronous `@opengeni/sdk/editable-artifacts` Worker API.
+ */
+export declare class NativeSpreadsheetSession {
+    private readonly runtime;
+    private readonly session;
+    readonly kind: "native";
+    readonly modality: "spreadsheet";
+    readonly target: NativeArtifactRuntimeTarget;
+    readonly capabilities: ArtifactKernelCapabilities;
+    readonly buildIdentity: string;
+    private constructor();
+    static create(runtime: ArtifactKernelRuntime, replicaNamespace: bigint): NativeSpreadsheetSession;
+    static open(runtime: ArtifactKernelRuntime, snapshot: Uint8Array): NativeSpreadsheetSession;
+    /**
+     * Authors one already-canonical mutation. Rust independently validates the
+     * exact OGATX/OGASC bytes, resolves typed operations, applies atomically, and
+     * returns the whole canonical OGACO transaction.
+     */
+    authorTransaction(intentBytes: Uint8Array, resolvedBaseBytes: Uint8Array): Uint8Array;
+    /** Encodes one identity-free typed command batch and authors it atomically. */
+    authorCommands(input: NativeSpreadsheetAuthorCommandsInput): NativeSpreadsheetAuthoredTransaction;
+    /** Replays one whole authoritative OGACO transaction atomically. */
+    applyCommitted(committedTransactionBytes: Uint8Array): void;
+    /**
+     * Executes one canonical OGAKQ request. Typed viewport/metadata helpers use
+     * the shared contract codec; this raw method remains useful at server byte
+     * boundaries and never exposes a Rust object layout.
+     */
+    query(queryBytes: Uint8Array): Uint8Array;
+    snapshot(): Uint8Array;
+    frontier(): Uint8Array;
+    stateHash(): string;
+    revision(): bigint;
+    fork(): NativeSpreadsheetSession;
+    isClosed(): boolean;
+    dispose(): void;
+}
+/** Exact synchronous N-API structured-document byte session. */
+export declare class NativeDocumentSession {
+    private readonly runtime;
+    private readonly session;
+    readonly kind: "native";
+    readonly modality: "document";
+    readonly target: NativeArtifactRuntimeTarget;
+    readonly capabilities: ArtifactKernelCapabilities;
+    readonly buildIdentity: string;
+    private constructor();
+    static create(runtime: ArtifactKernelRuntime, namespace: bigint): NativeDocumentSession;
+    static open(runtime: ArtifactKernelRuntime, snapshot: Uint8Array): NativeDocumentSession;
+    applyCommands(commands: Uint8Array): Uint8Array;
+    query(request: Uint8Array): Uint8Array;
+    snapshot(): Uint8Array;
+    revision(): bigint;
+    stateHash(): string;
+    fork(): NativeDocumentSession;
+    isClosed(): boolean;
+    dispose(): void;
+}
+/** Exact synchronous N-API presentation byte session. */
+export declare class NativePresentationSession {
+    private readonly runtime;
+    private readonly session;
+    readonly kind: "native";
+    readonly modality: "presentation";
+    readonly target: NativeArtifactRuntimeTarget;
+    readonly capabilities: ArtifactKernelCapabilities;
+    readonly buildIdentity: string;
+    private constructor();
+    static create(runtime: ArtifactKernelRuntime, namespace: bigint): NativePresentationSession;
+    static open(runtime: ArtifactKernelRuntime, snapshot: Uint8Array): NativePresentationSession;
+    applyCommands(commands: Uint8Array): Uint8Array;
+    query(request: Uint8Array): Uint8Array;
+    snapshot(): Uint8Array;
+    revision(): bigint;
+    stateHash(): string;
+    fork(): NativePresentationSession;
+    isClosed(): boolean;
+    dispose(): void;
+}
+/** Exact synchronous N-API retained-font text-layout session. */
+export declare class NativeTextLayoutSession {
+    private readonly session;
+    readonly kind: "native";
+    readonly modality: "text-layout";
+    readonly target: NativeArtifactRuntimeTarget;
+    readonly capabilities: ArtifactKernelCapabilities;
+    readonly buildIdentity: string;
+    private constructor();
+    static open(runtime: ArtifactKernelRuntime, fontBundle: Uint8Array): NativeTextLayoutSession;
+    layout(request: Uint8Array): Uint8Array;
+    isClosed(): boolean;
+    dispose(): void;
+}
+/** Creates a production modality session; unsupported Rust modes fail closed. */
+export declare function createNativeArtifactSession(runtime: ArtifactKernelRuntime, input: CreateNativeArtifactSessionInput): NativeArtifactSession;
+/** Opens a production modality session; unsupported Rust modes fail closed. */
+export declare function openNativeArtifactSession(runtime: ArtifactKernelRuntime, input: OpenNativeArtifactSessionInput): NativeArtifactSession;

package/dist/native.js

@@ -0,0 +1,31 @@
+import {
+  NativeDocumentSession,
+  NativePresentationSession,
+  NativeSpreadsheetSession,
+  NativeTextLayoutSession,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  assertCanonicalSpreadsheetArtifactCommandBytes,
+  createNativeArtifactSession,
+  decodeSpreadsheetArtifactCommandBatch,
+  editableArtifactStableId,
+  encodeSpreadsheetArtifactCommandBatch,
+  openNativeArtifactSession,
+  spreadsheetSheetId
+} from "./chunk-B2ZJRZDA.js";
+import "./chunk-N2IHNWBS.js";
+import "./chunk-VUNV25KB.js";
+export {
+  NativeDocumentSession,
+  NativePresentationSession,
+  NativeSpreadsheetSession,
+  NativeTextLayoutSession,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  assertCanonicalSpreadsheetArtifactCommandBytes,
+  createNativeArtifactSession,
+  decodeSpreadsheetArtifactCommandBatch,
+  editableArtifactStableId,
+  encodeSpreadsheetArtifactCommandBatch,
+  openNativeArtifactSession,
+  spreadsheetSheetId
+};
+//# sourceMappingURL=native.js.map

package/dist/native.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/office-import.d.ts

@@ -0,0 +1,48 @@
+export type ArtifactOfficeModality = "spreadsheet" | "document" | "presentation";
+export type ArtifactOfficeMimeType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+export type PreparedArtifactOfficeImport = Readonly<{
+    source: Readonly<{
+        filename: string;
+        byteSize: number;
+        contentHash: `sha256:${string}`;
+        mimeType: ArtifactOfficeMimeType;
+    }>;
+    snapshot: Readonly<{
+        modality: "spreadsheet";
+        bytes: Uint8Array;
+        byteSize: number;
+        contentHash: `sha256:${string}`;
+        stateHash: `sha256:${string}`;
+        modelSchemaVersion: 1;
+        kernelVersion: string;
+        coveredCausalFrontier: readonly Readonly<{
+            replicaId: string;
+            counter: number;
+        }>[];
+        operationProtocolVersion: 1;
+        crdtStateVersion: 1;
+    }> | Readonly<{
+        modality: "document" | "presentation";
+        bytes: Uint8Array;
+        byteSize: number;
+        contentHash: `sha256:${string}`;
+        stateHash: `sha256:${string}`;
+        modelSchemaVersion: 1;
+        kernelVersion: string;
+        nativeRevision: number;
+    }>;
+}>;
+/** The Office container is valid input bytes but cannot be modeled safely. */
+export declare class ArtifactOfficeSourceUnsupportedError extends Error {
+    constructor(extension: ".xlsx" | ".docx" | ".pptx", options: ErrorOptions);
+}
+/** Import bounded Office bytes through the exact verified facade, without a local path. */
+export declare function prepareArtifactOfficeImport(input: Readonly<{
+    facade: unknown;
+    modality: ArtifactOfficeModality;
+    filename: string;
+    mimeType: ArtifactOfficeMimeType;
+    bytes: Uint8Array;
+    expectedRuntimeTarget: string;
+    expectedKernelVersion: string;
+}>): Promise<PreparedArtifactOfficeImport>;

package/dist/office-import.js

@@ -0,0 +1,154 @@
+import "./chunk-VUNV25KB.js";
+
+// src/office-import.ts
+import { createHash } from "crypto";
+import { decodeEditableArtifactCausalFrontier } from "@opengeni/contracts/editable-artifact-causal-frontier";
+import { EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES } from "@opengeni/contracts/editable-artifacts";
+var ArtifactOfficeSourceUnsupportedError = class extends Error {
+  constructor(extension, options) {
+    super(`The ${extension} source could not be imported`, options);
+    this.name = "ArtifactOfficeSourceUnsupportedError";
+  }
+};
+async function prepareArtifactOfficeImport(input) {
+  const expected = officeFormat(input.modality);
+  if (input.mimeType !== expected.mimeType) {
+    throw new TypeError("Office MIME type does not match artifact modality");
+  }
+  if (!input.filename.toLowerCase().endsWith(expected.extension)) {
+    throw new TypeError(`Office filename must end with ${expected.extension}`);
+  }
+  if (!(input.bytes instanceof Uint8Array) || input.bytes.byteLength < 1) {
+    throw new TypeError("Office source bytes must be a nonempty Uint8Array");
+  }
+  if (input.bytes.byteLength > EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES) {
+    throw new RangeError("Office source exceeds the editable artifact product limit");
+  }
+  const sourceBytes = Uint8Array.from(input.bytes);
+  const module = exactModule(input.facade);
+  const fileBlob = exactNamespace(module.FileBlob, "FileBlob");
+  const fromBytes = exactFunction(fileBlob.fromBytes, "FileBlob.fromBytes");
+  const createSnapshot = exactFunction(module.createArtifactSnapshot, "createArtifactSnapshot");
+  const disposeArtifact = exactFunction(module.disposeArtifact, "disposeArtifact");
+  const importer = officeImporter(module, input.modality);
+  const blob = Reflect.apply(fromBytes, fileBlob, [
+    sourceBytes,
+    { name: input.filename, type: input.mimeType }
+  ]);
+  let artifact;
+  try {
+    artifact = await importer(blob);
+  } catch (cause) {
+    throw new ArtifactOfficeSourceUnsupportedError(expected.extension, { cause });
+  }
+  try {
+    const snapshot = validateSnapshot(
+      Reflect.apply(createSnapshot, module, [artifact]),
+      input.modality,
+      input.expectedRuntimeTarget,
+      input.expectedKernelVersion
+    );
+    return Object.freeze({
+      source: Object.freeze({
+        filename: input.filename,
+        byteSize: sourceBytes.byteLength,
+        contentHash: sha256(sourceBytes),
+        mimeType: input.mimeType
+      }),
+      snapshot
+    });
+  } finally {
+    Reflect.apply(disposeArtifact, module, [artifact]);
+  }
+}
+function validateSnapshot(value, modality, expectedRuntimeTarget, expectedKernelVersion) {
+  const snapshot = exactNamespace(value, "artifact snapshot");
+  if (snapshot.schemaVersion !== 1 || snapshot.modality !== modality || snapshot.runtimeTarget !== expectedRuntimeTarget || snapshot.kernelVersion !== expectedKernelVersion || snapshot.modelSchemaVersion !== 1 || snapshot.snapshotVersion !== 1 || !/^sha256:[0-9a-f]{64}$/u.test(snapshot.stateHash)) {
+    throw new TypeError("Imported snapshot differs from the verified native runtime boundary");
+  }
+  if (!(snapshot.snapshotBytes instanceof Uint8Array) || snapshot.snapshotBytes.byteLength < 1 || snapshot.snapshotBytes.byteLength > EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES) {
+    throw new TypeError("Imported snapshot bytes are outside the product limit");
+  }
+  const bytes = Uint8Array.from(snapshot.snapshotBytes);
+  const common = {
+    bytes,
+    byteSize: bytes.byteLength,
+    contentHash: sha256(bytes),
+    stateHash: snapshot.stateHash,
+    modelSchemaVersion: 1,
+    kernelVersion: snapshot.kernelVersion
+  };
+  if (snapshot.modality === "spreadsheet") {
+    if (!(snapshot.coveredCausalFrontierBytes instanceof Uint8Array) || snapshot.operationProtocolVersion !== 1 || snapshot.crdtStateVersion !== 1) {
+      throw new TypeError("Imported spreadsheet snapshot coverage is invalid");
+    }
+    return Object.freeze({
+      ...common,
+      modality: "spreadsheet",
+      coveredCausalFrontier: decodeEditableArtifactCausalFrontier(
+        snapshot.coveredCausalFrontierBytes
+      ),
+      operationProtocolVersion: 1,
+      crdtStateVersion: 1
+    });
+  }
+  if (!Number.isSafeInteger(snapshot.nativeRevision) || snapshot.nativeRevision < 0) {
+    throw new TypeError("Imported serialized snapshot revision is invalid");
+  }
+  return Object.freeze({
+    ...common,
+    modality: snapshot.modality,
+    nativeRevision: snapshot.nativeRevision
+  });
+}
+function officeImporter(module, modality) {
+  const namespaceName = modality === "spreadsheet" ? "SpreadsheetFile" : modality === "document" ? "DocumentFile" : "PresentationFile";
+  const methodName = modality === "spreadsheet" ? "importXlsx" : modality === "document" ? "importDocx" : "importPptx";
+  const namespace = exactNamespace(module[namespaceName], namespaceName);
+  const method = exactFunction(namespace[methodName], `${namespaceName}.${methodName}`);
+  return async (blob) => await Reflect.apply(method, namespace, [blob]);
+}
+function officeFormat(modality) {
+  if (modality === "spreadsheet") {
+    return {
+      extension: ".xlsx",
+      mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    };
+  }
+  if (modality === "document") {
+    return {
+      extension: ".docx",
+      mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    };
+  }
+  return {
+    extension: ".pptx",
+    mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+  };
+}
+function exactModule(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError("Verified artifact facade must be a module namespace");
+  }
+  return value;
+}
+function exactNamespace(value, label) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    throw new TypeError(`Verified artifact facade is missing ${label}`);
+  }
+  return value;
+}
+function exactFunction(value, label) {
+  if (typeof value !== "function") {
+    throw new TypeError(`Verified artifact facade is missing ${label}()`);
+  }
+  return value;
+}
+function sha256(bytes) {
+  return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+export {
+  ArtifactOfficeSourceUnsupportedError,
+  prepareArtifactOfficeImport
+};
+//# sourceMappingURL=office-import.js.map

package/dist/office-import.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/office-import.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { decodeEditableArtifactCausalFrontier } from \"@opengeni/contracts/editable-artifact-causal-frontier\";\nimport { EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES } from \"@opengeni/contracts/editable-artifacts\";\nimport type { ArtifactSnapshot } from \"./snapshot\";\n\nexport type ArtifactOfficeModality = \"spreadsheet\" | \"document\" | \"presentation\";\nexport type ArtifactOfficeMimeType =\n  | \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\"\n  | \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\"\n  | \"application/vnd.openxmlformats-officedocument.presentationml.presentation\";\n\nexport type PreparedArtifactOfficeImport = Readonly<{\n  source: Readonly<{\n    filename: string;\n    byteSize: number;\n    contentHash: `sha256:${string}`;\n    mimeType: ArtifactOfficeMimeType;\n  }>;\n  snapshot:\n    | Readonly<{\n        modality: \"spreadsheet\";\n        bytes: Uint8Array;\n        byteSize: number;\n        contentHash: `sha256:${string}`;\n        stateHash: `sha256:${string}`;\n        modelSchemaVersion: 1;\n        kernelVersion: string;\n        coveredCausalFrontier: readonly Readonly<{ replicaId: string; counter: number }>[];\n        operationProtocolVersion: 1;\n        crdtStateVersion: 1;\n      }>\n    | Readonly<{\n        modality: \"document\" | \"presentation\";\n        bytes: Uint8Array;\n        byteSize: number;\n        contentHash: `sha256:${string}`;\n        stateHash: `sha256:${string}`;\n        modelSchemaVersion: 1;\n        kernelVersion: string;\n        nativeRevision: number;\n      }>;\n}>;\n\n/** The Office container is valid input bytes but cannot be modeled safely. */\nexport class ArtifactOfficeSourceUnsupportedError extends Error {\n  constructor(extension: \".xlsx\" | \".docx\" | \".pptx\", options: ErrorOptions) {\n    super(`The ${extension} source could not be imported`, options);\n    this.name = \"ArtifactOfficeSourceUnsupportedError\";\n  }\n}\n\n/** Import bounded Office bytes through the exact verified facade, without a local path. */\nexport async function prepareArtifactOfficeImport(\n  input: Readonly<{\n    facade: unknown;\n    modality: ArtifactOfficeModality;\n    filename: string;\n    mimeType: ArtifactOfficeMimeType;\n    bytes: Uint8Array;\n    expectedRuntimeTarget: string;\n    expectedKernelVersion: string;\n  }>,\n): Promise<PreparedArtifactOfficeImport> {\n  const expected = officeFormat(input.modality);\n  if (input.mimeType !== expected.mimeType) {\n    throw new TypeError(\"Office MIME type does not match artifact modality\");\n  }\n  if (!input.filename.toLowerCase().endsWith(expected.extension)) {\n    throw new TypeError(`Office filename must end with ${expected.extension}`);\n  }\n  if (!(input.bytes instanceof Uint8Array) || input.bytes.byteLength < 1) {\n    throw new TypeError(\"Office source bytes must be a nonempty Uint8Array\");\n  }\n  if (input.bytes.byteLength > EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES) {\n    throw new RangeError(\"Office source exceeds the editable artifact product limit\");\n  }\n  const sourceBytes = Uint8Array.from(input.bytes);\n  const module = exactModule(input.facade);\n  const fileBlob = exactNamespace(module.FileBlob, \"FileBlob\");\n  const fromBytes = exactFunction(fileBlob.fromBytes, \"FileBlob.fromBytes\");\n  const createSnapshot = exactFunction(module.createArtifactSnapshot, \"createArtifactSnapshot\");\n  const disposeArtifact = exactFunction(module.disposeArtifact, \"disposeArtifact\");\n  const importer = officeImporter(module, input.modality);\n  const blob = Reflect.apply(fromBytes, fileBlob, [\n    sourceBytes,\n    { name: input.filename, type: input.mimeType },\n  ]);\n  let artifact: unknown;\n  try {\n    artifact = await importer(blob);\n  } catch (cause) {\n    throw new ArtifactOfficeSourceUnsupportedError(expected.extension, { cause });\n  }\n  try {\n    const snapshot = validateSnapshot(\n      Reflect.apply(createSnapshot, module, [artifact]),\n      input.modality,\n      input.expectedRuntimeTarget,\n      input.expectedKernelVersion,\n    );\n    return Object.freeze({\n      source: Object.freeze({\n        filename: input.filename,\n        byteSize: sourceBytes.byteLength,\n        contentHash: sha256(sourceBytes),\n        mimeType: input.mimeType,\n      }),\n      snapshot,\n    });\n  } finally {\n    Reflect.apply(disposeArtifact, module, [artifact]);\n  }\n}\n\nfunction validateSnapshot(\n  value: unknown,\n  modality: ArtifactOfficeModality,\n  expectedRuntimeTarget: string,\n  expectedKernelVersion: string,\n): PreparedArtifactOfficeImport[\"snapshot\"] {\n  const snapshot = exactNamespace(value, \"artifact snapshot\") as unknown as ArtifactSnapshot;\n  if (\n    snapshot.schemaVersion !== 1 ||\n    snapshot.modality !== modality ||\n    snapshot.runtimeTarget !== expectedRuntimeTarget ||\n    snapshot.kernelVersion !== expectedKernelVersion ||\n    snapshot.modelSchemaVersion !== 1 ||\n    snapshot.snapshotVersion !== 1 ||\n    !/^sha256:[0-9a-f]{64}$/u.test(snapshot.stateHash)\n  ) {\n    throw new TypeError(\"Imported snapshot differs from the verified native runtime boundary\");\n  }\n  if (\n    !(snapshot.snapshotBytes instanceof Uint8Array) ||\n    snapshot.snapshotBytes.byteLength < 1 ||\n    snapshot.snapshotBytes.byteLength > EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES\n  ) {\n    throw new TypeError(\"Imported snapshot bytes are outside the product limit\");\n  }\n  const bytes = Uint8Array.from(snapshot.snapshotBytes);\n  const common = {\n    bytes,\n    byteSize: bytes.byteLength,\n    contentHash: sha256(bytes),\n    stateHash: snapshot.stateHash as `sha256:${string}`,\n    modelSchemaVersion: 1 as const,\n    kernelVersion: snapshot.kernelVersion,\n  };\n  if (snapshot.modality === \"spreadsheet\") {\n    if (\n      !(snapshot.coveredCausalFrontierBytes instanceof Uint8Array) ||\n      snapshot.operationProtocolVersion !== 1 ||\n      snapshot.crdtStateVersion !== 1\n    ) {\n      throw new TypeError(\"Imported spreadsheet snapshot coverage is invalid\");\n    }\n    return Object.freeze({\n      ...common,\n      modality: \"spreadsheet\" as const,\n      coveredCausalFrontier: decodeEditableArtifactCausalFrontier(\n        snapshot.coveredCausalFrontierBytes,\n      ),\n      operationProtocolVersion: 1 as const,\n      crdtStateVersion: 1 as const,\n    });\n  }\n  if (!Number.isSafeInteger(snapshot.nativeRevision) || snapshot.nativeRevision < 0) {\n    throw new TypeError(\"Imported serialized snapshot revision is invalid\");\n  }\n  return Object.freeze({\n    ...common,\n    modality: snapshot.modality,\n    nativeRevision: snapshot.nativeRevision,\n  });\n}\n\nfunction officeImporter(\n  module: Record<string, unknown>,\n  modality: ArtifactOfficeModality,\n): (input: unknown) => Promise<unknown> {\n  const namespaceName =\n    modality === \"spreadsheet\"\n      ? \"SpreadsheetFile\"\n      : modality === \"document\"\n        ? \"DocumentFile\"\n        : \"PresentationFile\";\n  const methodName =\n    modality === \"spreadsheet\"\n      ? \"importXlsx\"\n      : modality === \"document\"\n        ? \"importDocx\"\n        : \"importPptx\";\n  const namespace = exactNamespace(module[namespaceName], namespaceName);\n  const method = exactFunction(namespace[methodName], `${namespaceName}.${methodName}`);\n  return async (blob) => await Reflect.apply(method, namespace, [blob]);\n}\n\nfunction officeFormat(modality: ArtifactOfficeModality): Readonly<{\n  extension: \".xlsx\" | \".docx\" | \".pptx\";\n  mimeType: ArtifactOfficeMimeType;\n}> {\n  if (modality === \"spreadsheet\") {\n    return {\n      extension: \".xlsx\",\n      mimeType: \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\",\n    };\n  }\n  if (modality === \"document\") {\n    return {\n      extension: \".docx\",\n      mimeType: \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\",\n    };\n  }\n  return {\n    extension: \".pptx\",\n    mimeType: \"application/vnd.openxmlformats-officedocument.presentationml.presentation\",\n  };\n}\n\nfunction exactModule(value: unknown): Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(\"Verified artifact facade must be a module namespace\");\n  }\n  return value as Record<string, unknown>;\n}\n\nfunction exactNamespace(value: unknown, label: string): Record<string, unknown> {\n  if ((typeof value !== \"object\" && typeof value !== \"function\") || value === null) {\n    throw new TypeError(`Verified artifact facade is missing ${label}`);\n  }\n  return value as Record<string, unknown>;\n}\n\nfunction exactFunction(value: unknown, label: string): (...args: unknown[]) => unknown {\n  if (typeof value !== \"function\") {\n    throw new TypeError(`Verified artifact facade is missing ${label}()`);\n  }\n  return value as (...args: unknown[]) => unknown;\n}\n\nfunction sha256(bytes: Uint8Array): `sha256:${string}` {\n  return `sha256:${createHash(\"sha256\").update(bytes).digest(\"hex\")}`;\n}\n"],"mappings":"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","names":[]}

package/dist/presentation-pptx-api.d.ts

@@ -0,0 +1,60 @@
+export declare const PPTX_MEDIA_TYPE: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+export type PresentationPptxFeature = "animation" | "audio" | "custom-geometry" | "connector" | "embedded-object" | "group" | "hyperlink" | "master" | "layout" | "media" | "placeholder" | "source-only" | "smart-art" | "table-style" | "theme" | "transition" | "unsupported-chart" | "video";
+export type PresentationFidelityIssue = {
+    code: "content-preserved-in-source" | "content-will-be-discarded" | "group-will-be-flattened" | "style-approximated";
+    severity: "warning" | "error";
+    feature: PresentationPptxFeature;
+    message: string;
+    parts?: readonly string[];
+};
+export type PresentationPptxImportLimits = {
+    compressedBytes: number;
+    expandedBytes: number;
+    entryBytes: number;
+    entries: number;
+    compressionRatio: number;
+    totalXmlBytes: number;
+    xmlBytes: number;
+    xmlDepth: number;
+    xmlNodes: number;
+    xmlAttributesPerElement: number;
+    relationshipsPerPart: number;
+    relationships: number;
+    slides: number;
+    elements: number;
+    textCharacters: number;
+    imageBytes: number;
+    chartPoints: number;
+    nestedPackageBytes: number;
+    nestedExpandedBytes: number;
+    nestedEntries: number;
+    retainedBytes: number;
+};
+export type PresentationPptxImportOptions = {
+    /** Preserve unsupported, inert content in the original package or reject it. */
+    unsupportedContent?: "preserve" | "error";
+    /** Every limit is applied before or while allocating decoded package state. */
+    limits?: Partial<PresentationPptxImportLimits>;
+};
+export type PresentationPptxExportOptions = {
+    fileName?: string;
+    /** Explicitly acknowledge content the editable model cannot regenerate. */
+    unsupportedContent?: "error" | "discard";
+};
+export type PresentationLossPreservationEnvelope = {
+    version: 1;
+    mediaType: typeof PPTX_MEDIA_TYPE;
+    sourceBytes: Uint8Array;
+    sourceDigest: string;
+    unsupportedParts: readonly string[];
+    modelDigest: string;
+};
+export declare class PresentationFidelityError extends Error {
+    readonly issues: readonly PresentationFidelityIssue[];
+    constructor(message: string, issues: readonly PresentationFidelityIssue[]);
+}
+export declare class PresentationSecurityError extends Error {
+    readonly code: "active-content" | "encrypted-content" | "external-relationship" | "invalid-package" | "limit-exceeded" | "unsafe-xml";
+    readonly entryName?: string | undefined;
+    constructor(message: string, code: "active-content" | "encrypted-content" | "external-relationship" | "invalid-package" | "limit-exceeded" | "unsafe-xml", entryName?: string | undefined);
+}

package/dist/presentation-pptx-import.d.ts

@@ -0,0 +1,5 @@
+import { FileBlob } from "./file-blob.js";
+import { Presentation } from "./presentation.js";
+import { type PresentationPptxImportLimits, type PresentationPptxImportOptions } from "./presentation-pptx-api.js";
+export declare const DEFAULT_PPTX_IMPORT_LIMITS: PresentationPptxImportLimits;
+export declare function importPresentationPptx(input: FileBlob | Blob | ArrayBuffer | Uint8Array, options?: PresentationPptxImportOptions): Promise<Presentation>;

package/dist/presentation-pptx-state-digest-765CZZED.js

@@ -0,0 +1,10 @@
+import {
+  presentationModelDigest,
+  sha256Hex
+} from "./chunk-5XIA6KHZ.js";
+import "./chunk-VUNV25KB.js";
+export {
+  presentationModelDigest,
+  sha256Hex
+};
+//# sourceMappingURL=presentation-pptx-state-digest-765CZZED.js.map

package/dist/presentation-pptx-state-digest-765CZZED.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/presentation-pptx-state-digest.d.ts

@@ -0,0 +1,3 @@
+import type { Presentation } from "./presentation.js";
+export declare function presentationModelDigest(presentation: Presentation): Promise<string>;
+export declare function sha256Hex(bytes: Uint8Array): Promise<string>;

package/dist/presentation-pptx-state.d.ts

@@ -0,0 +1,4 @@
+import type { Presentation } from "./presentation.js";
+import type { PresentationLossPreservationEnvelope } from "./presentation-pptx-api.js";
+export declare function presentationLossState(presentation: Presentation): PresentationLossPreservationEnvelope | undefined;
+export declare function setPresentationLossState(presentation: Presentation, envelope: PresentationLossPreservationEnvelope | undefined): void;

package/dist/presentation-pptx-xml.d.ts

@@ -0,0 +1,29 @@
+import { PresentationSecurityError, type PresentationPptxImportLimits } from "./presentation-pptx-api.js";
+export type PptxXmlNode = PptxXmlElement | {
+    type: "text";
+    value: string;
+};
+export type PptxXmlElement = {
+    type: "element";
+    name: string;
+    localName: string;
+    attributes: ReadonlyMap<string, string>;
+    /** Resolved namespace bindings, populated by parsePptxXmlPart validation. */
+    namespaceUri?: string;
+    attributeNamespaces?: ReadonlyMap<string, string | undefined>;
+    children: PptxXmlNode[];
+};
+export type PptxXmlBudget = {
+    limits: PresentationPptxImportLimits;
+    totalBytes: number;
+    totalNodes: number;
+};
+export declare function parsePptxXmlPart(bytes: Uint8Array, partName: string, budget: PptxXmlBudget): PptxXmlElement;
+export declare function pptxXmlChildren(element: PptxXmlElement | undefined): PptxXmlElement[];
+export declare function pptxXmlChild(element: PptxXmlElement | undefined, localName: string): PptxXmlElement | undefined;
+export declare function pptxXmlDescendants(element: PptxXmlElement | undefined, localName: string): PptxXmlElement[];
+export declare function pptxXmlAttribute(element: PptxXmlElement | undefined, localName: string): string | undefined;
+export declare function pptxXmlQualifiedAttribute(element: PptxXmlElement | undefined, qualifiedName: string): string | undefined;
+export declare function pptxXmlText(element: PptxXmlElement | undefined): string;
+export declare function pptxXmlDirectText(element: PptxXmlElement | undefined): string;
+export declare function pptxXmlSecurity(message: string, code: PresentationSecurityError["code"], entryName?: string): PresentationSecurityError;

package/dist/presentation-pptx.d.ts

@@ -0,0 +1,5 @@
+import { FileBlob } from "./file-blob.js";
+import { type Presentation } from "./presentation.js";
+import { type PresentationPptxExportOptions } from "./presentation-pptx-api.js";
+export { importPresentationPptx } from "./presentation-pptx-import.js";
+export declare function exportPresentationPptx(presentation: Presentation, options?: PresentationPptxExportOptions): Promise<FileBlob>;