iso2x-wasm 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,147 @@
+export type SourceReadFn = (offset: number, length: number) => Uint8Array;
+export interface SourceInfoResult {
+    titleId: string;
+    contentType: string;
+    detectedTitle: string | undefined;
+}
+export type ConversionFormat = 'god' | 'xiso' | 'extracted' | 'ciso' | 'cci' | 'zar';
+/**
+ * `fetchSize` lives here, and only here - it's a read-side setting (bytes
+ * pulled per `readFn` call while opening/reading the source container).
+ * A write-side fetch size isn't a meaningful concept, so it has no place
+ * on `OpenConversionSessionOptions`.
+ */
+export interface SourceOptions {
+    format: ConversionFormat;
+    fetchSize?: number;
+}
+export interface SourcePart {
+    name: string;
+    size: number;
+    readFn: SourceReadFn;
+}
+/**
+ * xiso's own write-mode enum (wire values are these lowercase strings):
+ *
+ * - `'trim'` - cuts trailing padding after the last used byte; nothing is
+ *   zeroed, so interior gaps pass through untouched.
+ * - `'zero'` - zeroes unused sectors in place without trimming; total size
+ *   matches the source (Xbox 360 images are an exception: still trimmed
+ *   but not zeroed).
+ * - `'full'` - full reauthor via a fresh XDVDFS rebuild. Slowest, but
+ *   independent of source layout. Default when `mode` is omitted.
+ *
+ * Not the same shape as `ScrubMode` below despite both being three-option
+ * "how much to reprocess" enums: `'trim'`/`'zero'` are independent
+ * operations xiso can apply separately, while `ScrubMode` only exposes
+ * "neither" or "both together". `'full'` is the one variant that's
+ * identical between the two.
+ */
+export type XisoMode = 'trim' | 'zero' | 'full';
+/**
+ * ciso/cci/god's shared write-mode enum (wire values are these lowercase
+ * strings):
+ *
+ * - `'none'` - straight sector copy, no trim, no zero, no directory scan.
+ * - `'partial'` - trims trailing padding and zeroes interior gaps in one
+ *   pass. On original Xbox (OGX) images this also tries to leave the
+ *   disc's security-sector region alone; on Xbox 360 images interior gaps
+ *   are never zeroed, only trimmed.
+ * - `'full'` - full reauthor via a fresh XDVDFS rebuild. Slowest, but
+ *   independent of source layout. Default when `mode` is omitted.
+ *
+ * ZAR has no equivalent - it has no padding/junk concept to trim or zero
+ * (every file is addressed by name, not by sector), so its
+ * `OpenConversionSessionOptions` variant doesn't take a `mode` at all.
+ */
+export type ScrubMode = 'none' | 'partial' | 'full';
+export type OpenConversionSessionOptions = {
+    format: 'god';
+    /** Write mode - see `ScrubMode`. Defaults to `'full'` if omitted. */
+    mode?: ScrubMode;
+    gameTitle?: string;
+} | {
+    format: 'xiso';
+    mode?: XisoMode;
+    split?: boolean;
+    outputName?: string;
+    sectorsPerChunk?: number;
+} | {
+    format: 'ciso';
+    /** Write mode - see `ScrubMode`. Defaults to `'full'` if omitted. */
+    mode?: ScrubMode;
+    /**
+     * Filename stem (no extension) the split output files are named
+     * after, e.g. "game" produces "game.1.cso", "game.2.cso", etc.
+     * once the image crosses the ~4.29 GB split threshold - and
+     * still produces "game.1.cso" even when it doesn't split.
+     */
+    outputName: string;
+} | {
+    format: 'cci';
+    /** Write mode - see `ScrubMode`. Defaults to `'full'` if omitted. */
+    mode?: ScrubMode;
+    /**
+     * Filename stem (no extension) the split output files are named
+     * after, e.g. "game" produces "game.1.cci", "game.2.cci", etc.
+     * once the image crosses the ~4.28 GB split threshold - and
+     * still produces "game.1.cci" even when it doesn't split. Unlike
+     * ciso, each ".N.cci" part is fully self-contained with its own
+     * header and index rather than one shared index in part 1 - see
+     * cciFileSplitPoint().
+     */
+    outputName: string;
+} | {
+    format: 'extracted';
+    skipSystemUpdate?: boolean;
+    /**
+     * ORs the HARD_DISK / NONSECURE_HARD_DISK / MEDIA_BOARD flags into
+     * the root-level `default.xbe`'s `allowed_media_types`, so the
+     * extracted title boots from a softmod HDD/media-board dashboard
+     * even if the original disc only authorized DVD. No-op if the
+     * source has no root-level `default.xbe` (e.g. a GoD/XEX source).
+     */
+    allowedMediaPatch?: boolean;
+    /**
+     * Overwrites the cert's `title_name` with this string (UTF-16 on
+     * the wasm side, truncated/zero-padded to the field's fixed
+     * 40-code-unit width). Typically pre-filled from
+     * `inspectSource(...).detectedTitle` and left editable in the UI.
+     * Omitted/undefined leaves the title untouched.
+     */
+    renameTitle?: string;
+} | {
+    format: 'zar';
+    /**
+     * Filename stem (no extension) the output file is named after,
+     * e.g. "game" produces "game.zar". Required, like ciso/cci's
+     * `outputName` - unlike xiso's optional one. ZAR is never split
+     * (unlike xiso/ciso/cci), so there's exactly one output file
+     * regardless of size.
+     */
+    outputName: string;
+};
+export type ResolvedSource = {
+    kind: 'file';
+    format: ConversionFormat;
+    readFn: SourceReadFn;
+    fileSize: number;
+} | {
+    kind: 'dir';
+    format: ConversionFormat;
+    parts: SourcePart[];
+};
+export interface SplitCciResult {
+    kind: 'cci-split';
+    parts: [string, string];
+}
+export interface SplitXisoResult {
+    kind: 'xiso-split';
+    parts: string[];
+}
+export interface IsoRootOffsetCandidate {
+    /** Variant name for the root-offset candidate, e.g. "Xsf", "Xgd2", "Xgd1", "Xgd3". */
+    name: string;
+    /** Byte offset of the XDVDFS volume from the start of the file for this candidate. */
+    rootOffset: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wasm/iso2x_wasm.d.ts

@@ -0,0 +1,216 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * One format-agnostic session type exposed to JS. The worker drives this
+ * the same way regardless of format - `nextChunk`/`isDone`/`totalUnits`
+ * is the entire contract, with `hashNextPart` as an extra pre-streaming
+ * step that's a no-op where nothing needs precomputing.
+ */
+export class ConversionSession {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    currentEntryName(): string | undefined;
+    /**
+     * Drives one bounded step of pre-streaming hashing/sizing (see
+     * `SessionInner::hash_next_part`). Call this in a loop from JS,
+     * yielding to the event loop between calls, until it returns `true`,
+     * *before* calling `nextChunk()`. Bounding each call's work is what
+     * makes hashing/sizing cancellable from JS.
+     */
+    hashNextPart(): boolean;
+    isDone(): boolean;
+    nextChunk(max_bytes: number): Uint8Array | undefined;
+    /**
+     * Array of `{ name, size }` for formats that produce multiple output
+     * files. Safe to call right after `open()`, before streaming - though
+     * it may be empty until sizing/hashing finishes, or permanently empty
+     * for single-stream formats.
+     */
+    outputManifest(): any;
+    totalUnits(): number;
+    /**
+     * See `ChunkSource::units_done` - `null` for every format except
+     * zar, where it's the authoritative "raw input bytes consumed" count
+     * to use instead of summing `nextChunk()`'s returned byte lengths.
+     */
+    unitsDone(): number | undefined;
+}
+
+export class SourceInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    contentType(): string;
+    detectedTitle(): string | undefined;
+    titleId(): string;
+}
+
+export function cciFileSplitPoint(): number;
+
+export function cciSectorSize(): number;
+
+export function cciSizingBatchSectors(): number;
+
+/**
+ * Chains `next_digest` onto the end of the hash list encoded in `mht_bytes`
+ * and returns the recomputed digest bytes.
+ *
+ * # Errors
+ *
+ * Returns an error if `mht_bytes` is not a valid hash list, or if
+ * `next_digest` is not exactly 20 bytes long.
+ */
+export function chainMhtDigest(mht_bytes: Uint8Array, next_digest: Uint8Array): Uint8Array;
+
+export function cisoFilePaddingModulus(): number;
+
+export function cisoFileSplitPoint(): number;
+
+export function cisoSectorSize(): number;
+
+export function cisoSizingBatchSectors(): number;
+
+/**
+ * Wasm wrapper around `core::source::detect_dir` - the directory-shape
+ * path (God/Extracted). Takes the flat list of forward-slash-normalized
+ * relative paths for every regular file in the dropped folder.
+ *
+ * Returns `None` when the listing matches neither shape (e.g. a folder of
+ * loose split-XISO parts) - the caller should resolve each entry via
+ * `detectFormat` instead.
+ */
+export function detectDirFormat(entries: string[]): string | undefined;
+
+/**
+ * Wasm wrapper around `core::source::detect` - the single-file, magic-byte
+ * path (Xiso/Ciso/Cci). For a dropped folder use `detectDirFormat` instead.
+ *
+ * # Errors
+ *
+ * Returns an error if reading from `read_fn` fails or if the file's magic
+ * bytes don't match any known single-file format.
+ */
+export function detectFormat(read_fn: Function, file_size: number): string;
+
+/**
+ * Generates a bootable "default.xbe" attach stub for an OGX (original
+ * Xbox) source, so an ISO/CCI/CISO conversion output can still be
+ * launched from a softmod dashboard. Rejects `GoD` (XEX) sources - this
+ * only makes sense for OGX, and this function enforces that
+ * unconditionally regardless of what the caller has already checked.
+ *
+ * # Errors
+ *
+ * Returns an error if `source` is unresolved or invalid, if reading
+ * `source_parts` fails, if the source is a `GoD` (XEX) source rather than
+ * OGX, if the XDVDFS root or `default.xbe` can't be located, or if
+ * building the attach stub fails.
+ */
+export function generateAttachXbe(read_fn: Function, file_size: number, source: any, source_parts: any): Uint8Array;
+
+/**
+ * Shows title/content-type for a source, before its conversion session is opened.
+ * Image-backed sources are inspected by locating and parsing the XDVDFS
+ * root; an extracted source has no such root, so it's inspected instead
+ * by locating and parsing `default.xbe`/`default.xex` directly off the
+ * directory.
+ *
+ * # Errors
+ *
+ * Returns an error if `source` is unresolved or invalid, if reading
+ * `source_parts` fails, or if the launch executable / XDVDFS root can't
+ * be located or parsed for the resolved source.
+ */
+export function inspectSource(read_fn: Function, file_size: number, source: any, source_parts: any): SourceInfo;
+
+/**
+ * Exposes the root-offset candidates `IsoType::read` actually probes -
+ * Xsf, Xgd2, Xgd1, Xgd3, in that order (iso2god-rs's `iso/iso_type.rs`) -
+ * so JS callers reference the real values instead of hardcoding magic
+ * numbers that could silently drift if iso2god-rs reorders or changes them.
+ */
+export function isoRootOffsetCandidates(): Array<any>;
+
+export function mhtSize(): number;
+
+/**
+ * Opens a conversion session for the given source and the requested
+ * target-format `options`.
+ *
+ * # Errors
+ *
+ * Returns an error if `options` fails to deserialize into a known
+ * `FormatOptions` variant, if `source` is unresolved or invalid, if
+ * reading `source_parts` fails, or if the resolved source can't be
+ * opened as the requested target format (e.g. an extracted-only source
+ * requested as an image-only target).
+ */
+export function openConversionSession(read_fn: Function, file_size: number, options: any, source: any, source_parts: any): ConversionSession;
+
+export function xisoSplitMargin(): number;
+
+export function zarBlockSize(): number;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_conversionsession_free: (a: number, b: number) => void;
+    readonly __wbg_sourceinfo_free: (a: number, b: number) => void;
+    readonly cciFileSplitPoint: () => number;
+    readonly cciSectorSize: () => number;
+    readonly cciSizingBatchSectors: () => number;
+    readonly chainMhtDigest: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly cisoFilePaddingModulus: () => number;
+    readonly cisoFileSplitPoint: () => number;
+    readonly conversionsession_currentEntryName: (a: number, b: number) => void;
+    readonly conversionsession_hashNextPart: (a: number, b: number) => void;
+    readonly conversionsession_isDone: (a: number) => number;
+    readonly conversionsession_nextChunk: (a: number, b: number, c: number) => void;
+    readonly conversionsession_outputManifest: (a: number, b: number) => void;
+    readonly conversionsession_totalUnits: (a: number) => number;
+    readonly conversionsession_unitsDone: (a: number, b: number) => void;
+    readonly detectDirFormat: (a: number, b: number, c: number) => void;
+    readonly detectFormat: (a: number, b: number, c: number) => void;
+    readonly generateAttachXbe: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly inspectSource: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly isoRootOffsetCandidates: () => number;
+    readonly mhtSize: () => number;
+    readonly openConversionSession: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly sourceinfo_contentType: (a: number, b: number) => void;
+    readonly sourceinfo_detectedTitle: (a: number, b: number) => void;
+    readonly sourceinfo_titleId: (a: number, b: number) => void;
+    readonly zarBlockSize: () => number;
+    readonly cisoSectorSize: () => number;
+    readonly cisoSizingBatchSectors: () => number;
+    readonly xisoSplitMargin: () => number;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;