can1357/oh-my-pi · error · ArchiveError

Failed to encode ASAR archive

Error message

Failed to encode ASAR archive: ${describeError(error)}

What it means

encodeAsar wraps its whole encoding pipeline in a try/catch: any unexpected exception (JSON.stringify failure, TextEncoder issues, bugs in member handling) that is not already an ArchiveError is rethrown as ArchiveError(`Failed to encode ASAR archive: ${describeError(error)}`). ArchiveErrors thrown inside (size limits, path conflicts, allocation failures) pass through unchanged with their specific messages.

Solutions

1. Read the inner describeError message to identify the original failure cause.
2. Validate members before calling: each payload must be a Uint8Array and paths must be unique, non-conflicting strings.
3. If the message masks an allocation failure, treat it like the 'too large to encode in memory' case and shrink the payload.
4. Upgrade/report: if the underlying cause looks like a library bug, reproduce with the original error enabled by catching before this wrapper.

Example fix

// before
const members = new Map([["a.txt", "not-a-uint8array"]]); // string payload slips through untyped code
encodeAsar(members); // -> Failed to encode ASAR archive: ...
// after
const members = new Map([["a.txt", new TextEncoder().encode("hello")]]);
const payloads: Array<[string, Uint8Array]> = [...members].filter(([, v]) => v instanceof Uint8Array);
encodeAsar(payloads);

function validateMembers(members) {
  for (const [path, payload] of members) {
    if (typeof path !== "string" || path.length === 0) throw new Error(`bad member path: ${String(path)}`);
    if (!(payload instanceof Uint8Array)) throw new Error(`member '${path}' is not a Uint8Array`);
  }
}

function isAsarMember(v) {
  return Array.isArray(v) && typeof v[0] === "string" && v[1] instanceof Uint8Array;
}

try {
  return encodeAsar(members);
} catch (err) {
  if (err instanceof ArchiveError) {
    if (err.message.startsWith("Failed to encode ASAR archive")) {
      logger.error("asar encode failed", { cause: err.message });
    }
    throw err;
  }
  throw err;
}

When it happens

Trigger: Any non-ArchiveError exception inside encodeAsar — most commonly JSON.stringify throwing on circular structures if a custom root was constructed, or an underlying engine error during the output.set copies; i.e. anything that bypasses the pre-validated fast paths.

Common situations: Malformed member lists (non-Uint8Array payloads from an untyped call site), unexpected engine failures mid-copy on very large archives, or library version changes that altered internal invariants — surfaced here because the catch-all converts them into a uniform ArchiveError.

Related errors

• ASAR archive is too large to encode in memory
• ASAR archive is too large to encode safely
• ASAR header is too large to encode
• ASAR member ' ' failed SHA256 integrity verification
• ASAR member ' ' has an inconsistent size

AI-assisted analysis of can1357/oh-my-pi@9690622007 (2026-08-31). Data as JSON: /api/errors/d3c3652357f468fc. Report an issue: GitHub.

Appendix: source

Thrown at packages/utils/src/ar/asar.ts:478

		try {
			output = new Uint8Array(archiveSize);
		} catch {
			throw new ArchiveError("ASAR archive is too large to encode in memory");
		}
		writeUInt32LE(output, 0, 4);
		writeUInt32LE(output, 4, headerSize);
		writeUInt32LE(output, 8, innerPayloadSize);
		writeUInt32LE(output, 12, jsonBytes.byteLength);
		output.set(jsonBytes, ASAR_JSON_OFFSET);
		let offset = dataOffset;
		for (const payload of payloads) {
			output.set(payload, offset);
			offset += payload.byteLength;
		}
		return output;
	} catch (error) {
		if (error instanceof ArchiveError) throw error;
		throw new ArchiveError(`Failed to encode ASAR archive: ${describeError(error)}`);
	}
}

View on GitHub (pinned to 9690622007)