@pix3/vite-plugin 0.0.0-stage → 2.0.0-alpha.0

package/dist/build/strippable-runtime-modules.js

@@ -0,0 +1,309 @@
+/**
+ * Importers whose references do not pin anything, because they cannot survive in a player bundle
+ * on their own:
+ *
+ * - `core/SceneLoader` — the `switch` over every node type; a case whose type never appears in a
+ *   shipped scene is dead code that only constructs the stub.
+ * - `index` — the package barrel; the bundler drops re-exports nobody imports.
+ * - `behaviors/register-behaviors` — registers classes by id into a `Map`; a stub registers fine
+ *   and `ScriptRegistry.createComponent` reports the throw.
+ * - `core/SceneSaver` — never constructed by a player (see `SceneManager`'s optional saver), so it
+ *   tree-shakes out with everything it imports.
+ *
+ * @internal The import-graph guard (`strippable-runtime-modules.spec.ts`) reads it.
+ */
+export const NEUTRALISED_IMPORTERS = [
+    'core/SceneLoader',
+    'index',
+    'behaviors/register-behaviors',
+    'core/SceneSaver',
+];
+export const STRIPPABLE_RUNTIME_MODULES = [
+    // --- script components (`core:` behaviours) ---
+    { modulePath: 'behaviors/RotateBehavior', keepWhenMentioned: ['RotateBehavior', 'core:Rotate'] },
+    {
+        modulePath: 'behaviors/SimpleMoveBehavior',
+        keepWhenMentioned: ['SimpleMoveBehavior', 'core:SimpleMove'],
+    },
+    { modulePath: 'behaviors/SineBehavior', keepWhenMentioned: ['SineBehavior', 'core:Sine'] },
+    {
+        modulePath: 'behaviors/PinToNodeBehavior',
+        keepWhenMentioned: ['PinToNodeBehavior', 'core:PinToNode'],
+    },
+    { modulePath: 'behaviors/FollowBehavior', keepWhenMentioned: ['FollowBehavior', 'core:Follow'] },
+    { modulePath: 'behaviors/FadeBehavior', keepWhenMentioned: ['FadeBehavior', 'core:Fade'] },
+    {
+        modulePath: 'behaviors/RadialProgressBehavior',
+        keepWhenMentioned: ['RadialProgressBehavior', 'core:RadialProgress'],
+    },
+    {
+        modulePath: 'behaviors/PlaySoundBehavior',
+        keepWhenMentioned: ['PlaySoundBehavior', 'core:PlaySound'],
+    },
+    {
+        modulePath: 'behaviors/SfxOnSignalBehavior',
+        keepWhenMentioned: ['SfxOnSignalBehavior', 'core:SfxOnSignal'],
+    },
+    {
+        modulePath: 'behaviors/BurstOnSignalBehavior',
+        keepWhenMentioned: ['BurstOnSignalBehavior', 'core:BurstOnSignal'],
+    },
+    {
+        modulePath: 'behaviors/FreeOnSignalBehavior',
+        keepWhenMentioned: ['FreeOnSignalBehavior', 'core:FreeOnSignal'],
+    },
+    {
+        modulePath: 'behaviors/Hitbox2DBehavior',
+        keepWhenMentioned: ['Hitbox2DBehavior', 'core:Hitbox2D'],
+    },
+    {
+        modulePath: 'behaviors/PointAttachmentBehavior',
+        keepWhenMentioned: ['PointAttachmentBehavior', 'core:PointAttachment'],
+    },
+    {
+        modulePath: 'behaviors/CharacterVisual2DBehavior',
+        keepWhenMentioned: ['CharacterVisual2DBehavior', 'core:CharacterVisual2D'],
+    },
+    {
+        modulePath: 'behaviors/ReplicatedTransformBehavior',
+        keepWhenMentioned: ['ReplicatedTransformBehavior', 'core:ReplicatedTransform'],
+    },
+    {
+        modulePath: 'behaviors/NetworkedNodeBehavior',
+        keepWhenMentioned: ['NetworkedNodeBehavior', 'core:NetworkedNode'],
+        importers: ['behaviors/ReplicatedTransformBehavior'],
+    },
+    // --- node types ---
+    {
+        modulePath: 'nodes/2D/ColorRect2D',
+        keepWhenMentioned: ['ColorRect2D'],
+        // `UIControl2D.findPointerTarget` only tests `instanceof ColorRect2D`; against the stub that is
+        // false for every node, which is exactly right when no scene places one.
+        lazyValueImporters: ['nodes/2D/UI/UIControl2D'],
+    },
+    { modulePath: 'nodes/2D/CanvasLayer2D', keepWhenMentioned: ['CanvasLayer2D'] },
+    { modulePath: 'nodes/2D/TiledSprite2D', keepWhenMentioned: ['TiledSprite2D'] },
+    { modulePath: 'nodes/2D/SpineSkeleton2D', keepWhenMentioned: ['SpineSkeleton2D'] },
+    {
+        modulePath: 'nodes/2D/AnimatedSprite2D',
+        keepWhenMentioned: ['AnimatedSprite2D'],
+        importers: ['behaviors/PointAttachmentBehavior', 'behaviors/CharacterVisual2DBehavior'],
+    },
+    { modulePath: 'nodes/2D/UI/Bar2D', keepWhenMentioned: ['Bar2D'] },
+    { modulePath: 'nodes/2D/UI/Checkbox2D', keepWhenMentioned: ['Checkbox2D'] },
+    { modulePath: 'nodes/2D/UI/InventorySlot2D', keepWhenMentioned: ['InventorySlot2D'] },
+    { modulePath: 'nodes/2D/UI/Joystick2D', keepWhenMentioned: ['Joystick2D'] },
+    { modulePath: 'nodes/2D/UI/Slider2D', keepWhenMentioned: ['Slider2D'] },
+    { modulePath: 'nodes/3D/AmbientLightNode', keepWhenMentioned: ['AmbientLightNode'] },
+    { modulePath: 'nodes/3D/DirectionalLightNode', keepWhenMentioned: ['DirectionalLightNode'] },
+    { modulePath: 'nodes/3D/HemisphereLightNode', keepWhenMentioned: ['HemisphereLightNode'] },
+    { modulePath: 'nodes/3D/PointLightNode', keepWhenMentioned: ['PointLightNode'] },
+    { modulePath: 'nodes/3D/SpotLightNode', keepWhenMentioned: ['SpotLightNode'] },
+    // --- 2D collision and physics ---
+    {
+        // The polygon math: winding, convex decomposition, SAT, the world transform. It has no
+        // keep-names of its own — it is exactly as needed as the two services that use it, and the
+        // fixpoint below works that out.
+        modulePath: 'core/collision-shapes-2d',
+        keepWhenMentioned: [],
+        importers: ['core/Collision2DService', 'core/Physics2DService', 'core/physics-2d-narrowphase'],
+    },
+    {
+        modulePath: 'core/world-transform-2d',
+        keepWhenMentioned: [],
+        importers: ['core/Collision2DService', 'core/Physics2DService'],
+    },
+    {
+        modulePath: 'core/collision-polygon-config',
+        keepWhenMentioned: [],
+        importers: ['behaviors/Hitbox2DBehavior', 'behaviors/Collider2DBehavior'],
+    },
+    {
+        // Query-only 2D collision. `SceneService.collision2d` constructs it lazily, and a project that
+        // never writes the word cannot reach that getter — the NetworkService precedent, one line down.
+        modulePath: 'core/Collision2DService',
+        keepWhenMentioned: ['collision2d', 'Collision2D', 'Hitbox2D', 'core:Hitbox2D'],
+        // Hitbox2DBehavior imports only its TYPES, but reaches the service through the lazy
+        // `scene.collision2d` getter: a kept behaviour (placed by a scene, or constructed by a script
+        // as `new Hitbox2DBehavior()`) must keep the service — so it is an importer for the fixpoint.
+        importers: ['behaviors/Hitbox2DBehavior'],
+        lazyValueImporters: ['core/SceneService'],
+    },
+    {
+        modulePath: 'core/physics-2d-narrowphase',
+        keepWhenMentioned: [],
+        importers: ['core/Physics2DService'],
+    },
+    {
+        // ~20 KiB of solver. Same lazy-getter argument as `collision2d`; and `SceneRunner` reaches it
+        // through `SceneService.stepPhysics2D`, so it adds no value import of its own.
+        modulePath: 'core/Physics2DService',
+        keepWhenMentioned: [
+            'physics2d',
+            'Physics2D',
+            'PhysicsBody2D',
+            'core:PhysicsBody2D',
+            'Collider2D',
+            'core:Collider2D',
+            'core:PhysicsWorld2D',
+            'core:RevoluteJoint2D',
+            'RevoluteJoint2D',
+        ],
+        // The four behaviours import only types from here but reach the service through the lazy
+        // `scene.physics2d` getter (same as Hitbox2D): each one kept keeps the solver.
+        importers: [
+            'behaviors/PhysicsBody2DBehavior',
+            'behaviors/Collider2DBehavior',
+            'behaviors/PhysicsWorld2DBehavior',
+            'behaviors/RevoluteJoint2DBehavior',
+        ],
+        lazyValueImporters: ['core/SceneService'],
+    },
+    {
+        modulePath: 'behaviors/PhysicsBody2DBehavior',
+        keepWhenMentioned: ['PhysicsBody2DBehavior', 'core:PhysicsBody2D'],
+    },
+    {
+        modulePath: 'behaviors/Collider2DBehavior',
+        keepWhenMentioned: ['Collider2DBehavior', 'core:Collider2D'],
+    },
+    {
+        modulePath: 'behaviors/PhysicsWorld2DBehavior',
+        keepWhenMentioned: ['PhysicsWorld2DBehavior', 'core:PhysicsWorld2D'],
+    },
+    {
+        modulePath: 'behaviors/RevoluteJoint2DBehavior',
+        keepWhenMentioned: ['RevoluteJoint2DBehavior', 'core:RevoluteJoint2D'],
+    },
+    // --- tweens and trails ---
+    {
+        // `SceneService.tween` constructs it lazily, and the per-frame `updateTweens` hook is a null
+        // check on an instance nobody made — so a project that never writes the word cannot reach the
+        // getter (the `collision2d` / `network` precedent above).
+        modulePath: 'core/TweenApi',
+        keepWhenMentioned: ['tween', 'Tween', 'TweenApi'],
+        lazyValueImporters: ['core/SceneService'],
+    },
+    {
+        // The motion ribbon. `JuiceApi.trail()` is its only construction site, and nothing else in
+        // the runtime reaches it.
+        modulePath: 'core/trail-2d',
+        keepWhenMentioned: ['trail', 'Trail2D'],
+        lazyValueImporters: ['core/JuiceApi'],
+    },
+    // --- multiplayer ---
+    {
+        // ~59 KiB with its protocol tree. `SceneService.network` is a getter that constructs one
+        // lazily "so single-player scripts can touch it freely" — but a project that never writes the
+        // word `network` anywhere cannot reach that getter, and any project that does keeps the real
+        // service (see `NETWORK_MENTION_NAMES` in `scan.ts`).
+        modulePath: 'net/NetworkService',
+        keepWhenMentioned: [
+            'network',
+            'Network',
+            'NetworkService',
+            'setNetworkPrefabTable',
+            'NetworkedNode',
+            'ReplicatedTransform',
+            // `SceneService.netNodes` builds a binder on `this.network`: the same lazy construction.
+            'netNodes',
+        ],
+        importers: ['behaviors/NetworkedNodeBehavior', 'behaviors/ReplicatedTransformBehavior'],
+        // `NetworkNodeBinder` reads `host.network`, but only `SceneService.netNodes` constructs it
+        // (a keep-name above), so it reaches the service only where the project said so.
+        lazyValueImporters: ['core/SceneService', 'core/NetworkNodeBinder'],
+    },
+];
+/**
+ * The subset of {@link STRIPPABLE_RUNTIME_MODULES} that can leave a build in which
+ * `mentions(name)` is false for every name the entry (and, transitively, every entry that imports
+ * it) is kept by.
+ */
+export const resolveStrippableRuntimeModules = (mentions, 
+/** The module's value exports (from its real source); each one keeps it like a keep-name. */
+exportsOf = () => []) => {
+    const byPath = new Map(STRIPPABLE_RUNTIME_MODULES.map(entry => [entry.modulePath, entry]));
+    const stripped = new Set(STRIPPABLE_RUNTIME_MODULES.filter(entry => !entry.keepWhenMentioned.some(mentions) && !exportsOf(entry.modulePath).some(mentions)).map(entry => entry.modulePath));
+    // A module survives as long as anything that imports it survives. Iterate until that settles:
+    // un-stripping ReplicatedTransformBehavior, say, has to also rescue NetworkedNodeBehavior and
+    // through it NetworkService.
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const modulePath of [...stripped]) {
+            const importers = byPath.get(modulePath)?.importers ?? [];
+            if (importers.some(importer => !stripped.has(importer))) {
+                stripped.delete(modulePath);
+                changed = true;
+            }
+        }
+    }
+    return STRIPPABLE_RUNTIME_MODULES.filter(entry => stripped.has(entry.modulePath));
+};
+/** The value exports of a runtime module's source, by kind (what the stub has to re-declare). */
+const valueExportsOf = (moduleSource) => {
+    const classNames = new Set();
+    const functionNames = new Set();
+    const otherNames = new Set();
+    const declarationPattern = /export\s+(?:declare\s+)?(?:abstract\s+)?(class|const|function|async\s+function|let|var|enum)\s+([A-Za-z0-9_$]+)/g;
+    for (const match of moduleSource.matchAll(declarationPattern)) {
+        if (match[1] === 'class') {
+            classNames.add(match[2]);
+        }
+        else if (match[1].endsWith('function')) {
+            functionNames.add(match[2]);
+        }
+        else {
+            otherNames.add(match[2]);
+        }
+    }
+    // `export { a, b as c }` re-export lists (rare in node modules, but cheap to cover).
+    const listPattern = /export\s*\{([^}]*)\}(?!\s*from)/g;
+    for (const match of moduleSource.matchAll(listPattern)) {
+        for (const clause of match[1].split(',')) {
+            const name = clause
+                .trim()
+                .split(/\s+as\s+/)
+                .pop()
+                ?.trim();
+            if (name &&
+                /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) &&
+                !classNames.has(name) &&
+                !functionNames.has(name)) {
+                otherNames.add(name);
+            }
+        }
+    }
+    return { classNames, functionNames, otherNames };
+};
+/** Every value export name of a module's source (the names that keep it besides the table's). */
+export const valueExportNames = (moduleSource) => {
+    const { classNames, functionNames, otherNames } = valueExportsOf(moduleSource);
+    return [...classNames, ...functionNames, ...otherNames];
+};
+/**
+ * A drop-in replacement for a runtime module's source: same value exports, but every class throws
+ * if anything ever constructs it. Derived from the real source rather than hardcoded, so a renamed
+ * export cannot silently drift — and if a name is missed, the bundler fails the build with "no
+ * matching export" instead of shipping something broken.
+ *
+ * Types and interfaces need no stubs: the bundler erases type-only usages, so the importing module
+ * no longer references those names at all.
+ */
+export const buildStrippedModuleSource = (moduleSource, modulePath) => {
+    const { classNames, functionNames, otherNames } = valueExportsOf(moduleSource);
+    const strippedError = (name) => JSON.stringify(`[Pix3] ${name} was stripped from this build because nothing in the project referenced it at build time.`);
+    const lines = [`// Stripped from this build: nothing in the project mentions ${modulePath}.`];
+    for (const name of classNames) {
+        lines.push(`export class ${name} {`, `  static getPropertySchema() { return []; }`, `  constructor() { throw new Error(${strippedError(name)}); }`, `}`);
+    }
+    for (const name of functionNames) {
+        lines.push(`export function ${name}() { throw new Error(${strippedError(name)}); }`);
+    }
+    for (const name of otherNames) {
+        lines.push(`export const ${name} = undefined;`);
+    }
+    if (classNames.size === 0 && functionNames.size === 0 && otherNames.size === 0) {
+        lines.push('export {};');
+    }
+    return lines.join('\n') + '\n';
+};

package/dist/build/zip.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `build: 'zip'` (plan §B.6): nothing is inlined — the build's `index.html`, chunks and the
+ * assets emitted beside them go into one `fflate` archive at `<outDir>/<name>.zip`, with paths
+ * relative to `outDir` (unpack anywhere; the player's `ResourceManager('./')` is relative).
+ */
+export declare const zipDirectory: (outDir: string, zipName: string) => string;

package/dist/build/zip.js

@@ -0,0 +1,28 @@
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { zipSync } from 'fflate';
+/**
+ * `build: 'zip'` (plan §B.6): nothing is inlined — the build's `index.html`, chunks and the
+ * assets emitted beside them go into one `fflate` archive at `<outDir>/<name>.zip`, with paths
+ * relative to `outDir` (unpack anywhere; the player's `ResourceManager('./')` is relative).
+ */
+export const zipDirectory = (outDir, zipName) => {
+    const files = {};
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const absolute = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(absolute);
+            else if (entry.isFile()) {
+                const rel = relative(outDir, absolute).split(sep).join('/');
+                if (rel === zipName)
+                    continue;
+                files[rel] = new Uint8Array(readFileSync(absolute));
+            }
+        }
+    };
+    walk(outDir);
+    const zipPath = join(outDir, zipName);
+    writeFileSync(zipPath, zipSync(files, { level: 6 }));
+    return zipPath;
+};

package/dist/client/host-files.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `EditorHost.files` over `/__pix3/api/*` (`.plans/editor-core-port.md` §1.2). A failed call
+ * rejects with an `Error` carrying `failure: {code, status, message, currentHash?}` — the shape
+ * `@pix3/editor-core`'s `hostFailureOf` reads.
+ */
+export type HostFileErrorCode = 'not_found' | 'base_mismatch' | 'exists' | 'writer_superseded' | 'reserved_path' | 'bad_path' | 'not_a_file' | 'not_empty' | 'forbidden' | 'network' | 'other';
+export interface HostFileFailure {
+    readonly code: HostFileErrorCode;
+    readonly status: number;
+    /** The file a changeset failed on. */
+    readonly path?: string;
+    readonly currentHash?: string | null;
+    readonly message: string;
+}
+export interface HostManifestEntry {
+    readonly path: string;
+    readonly kind: 'file' | 'dir';
+    readonly size: number;
+    readonly mtime: number;
+    readonly sha256?: string;
+}
+export interface HostWriteOptions {
+    readonly ifMatch?: string;
+    readonly createOnly?: boolean;
+    readonly mutationId?: string;
+}
+export interface HostChangesetEntry {
+    readonly path: string;
+    readonly data: Uint8Array | string;
+    readonly ifMatch?: string;
+    readonly createOnly?: boolean;
+}
+export interface HostWriteResult {
+    readonly path: string;
+    readonly sha256: string;
+    readonly size: number;
+    readonly seq: number;
+    readonly mtime?: number;
+}
+export interface HostChangesetResult {
+    readonly seq: number;
+    readonly files: readonly HostWriteResult[];
+}
+/** What the files client needs from the connection. */
+export interface ApiCaller {
+    readonly base: string;
+    api(route: string, init?: RequestInit): Promise<Response>;
+}
+export declare class HostFileError extends Error {
+    readonly failure: HostFileFailure;
+    constructor(failure: HostFileFailure);
+}
+export declare const failureOf: (response: Response) => Promise<HostFileError>;
+export declare const networkError: (error: unknown) => HostFileError;
+export declare class HostFilesClient {
+    private readonly caller;
+    constructor(caller: ApiCaller);
+    private call;
+    private json;
+    read(path: string): Promise<{
+        bytes: Uint8Array;
+        sha256: string;
+    } | null>;
+    readText(path: string): Promise<string | null>;
+    head(path: string): Promise<{
+        sha256: string;
+        size: number;
+    } | null>;
+    write(path: string, data: Uint8Array | string, options?: HostWriteOptions): Promise<{
+        path: string;
+        sha256: string;
+        size: number;
+        seq: number;
+    }>;
+    /**
+     * Several files as one transaction (plan §C.4). A refusal names the file in `failure.path`;
+     * nothing was written then.
+     */
+    writeChangeset(entries: readonly HostChangesetEntry[], options?: {
+        mutationId?: string;
+    }): Promise<HostChangesetResult>;
+    mkdir(path: string): Promise<void>;
+    delete(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    move(from: string, to: string, options?: {
+        overwrite?: boolean;
+    }): Promise<void>;
+    manifest(): Promise<{
+        revision: string;
+        seq: number;
+        files: HostManifestEntry[];
+    }>;
+    hash(paths: readonly string[]): Promise<Record<string, string | null>>;
+    url(path: string): string;
+}

package/dist/client/host-files.js

@@ -0,0 +1,169 @@
+/**
+ * `EditorHost.files` over `/__pix3/api/*` (`.plans/editor-core-port.md` §1.2). A failed call
+ * rejects with an `Error` carrying `failure: {code, status, message, currentHash?}` — the shape
+ * `@pix3/editor-core`'s `hostFailureOf` reads.
+ */
+const KNOWN_CODES = new Set([
+    'not_found',
+    'base_mismatch',
+    'exists',
+    'writer_superseded',
+    'reserved_path',
+    'bad_path',
+    'not_a_file',
+    'not_empty',
+]);
+export class HostFileError extends Error {
+    failure;
+    constructor(failure) {
+        super(failure.message);
+        this.name = 'HostFileError';
+        this.failure = failure;
+    }
+}
+export const failureOf = async (response) => {
+    let body = {};
+    try {
+        body = (await response.json());
+    }
+    catch {
+        // not JSON
+    }
+    const raw = typeof body.error === 'string' ? body.error : '';
+    const code = KNOWN_CODES.has(raw)
+        ? raw
+        : response.status === 403
+            ? 'forbidden'
+            : response.status === 404
+                ? 'not_found'
+                : 'other';
+    return new HostFileError({
+        code,
+        status: response.status,
+        message: typeof body.message === 'string' ? body.message : `HTTP ${response.status}`,
+        ...(typeof body.path === 'string' ? { path: body.path } : {}),
+        ...('currentHash' in body ? { currentHash: body.currentHash ?? null } : {}),
+    });
+};
+export const networkError = (error) => new HostFileError({
+    code: 'network',
+    status: 0,
+    message: `The dev server did not answer: ${error instanceof Error ? error.message : String(error)}`,
+});
+/** Bytes as base64 without `Buffer` (this runs in the page); chunked to stay off the arg limit. */
+const toBase64 = (bytes) => {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    }
+    return btoa(binary);
+};
+const etagOf = (response) => (response.headers.get('etag') ?? '').replace(/^W\//, '').replace(/^"|"$/g, '');
+const q = (path) => `file?path=${encodeURIComponent(path)}`;
+export class HostFilesClient {
+    caller;
+    constructor(caller) {
+        this.caller = caller;
+    }
+    async call(route, init) {
+        try {
+            return await this.caller.api(route, init);
+        }
+        catch (error) {
+            throw networkError(error);
+        }
+    }
+    async json(route, body) {
+        const response = await this.call(route, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok)
+            throw await failureOf(response);
+        return (await response.json());
+    }
+    async read(path) {
+        const response = await this.call(q(path));
+        if (response.status === 404)
+            return null;
+        if (!response.ok)
+            throw await failureOf(response);
+        return { bytes: new Uint8Array(await response.arrayBuffer()), sha256: etagOf(response) };
+    }
+    async readText(path) {
+        const read = await this.read(path);
+        return read ? new TextDecoder().decode(read.bytes) : null;
+    }
+    async head(path) {
+        const response = await this.call(q(path), { method: 'HEAD' });
+        if (response.status === 404)
+            return null;
+        if (!response.ok)
+            throw await failureOf(response);
+        return { sha256: etagOf(response), size: Number(response.headers.get('content-length') ?? 0) };
+    }
+    async write(path, data, options = {}) {
+        const headers = { 'Content-Type': 'application/octet-stream' };
+        if (options.ifMatch)
+            headers['If-Match'] = options.ifMatch === '*' ? '*' : `"${options.ifMatch}"`;
+        if (options.createOnly)
+            headers['If-None-Match'] = '*';
+        if (options.mutationId)
+            headers['X-Mutation-Id'] = options.mutationId;
+        const response = await this.call(q(path), {
+            method: 'PUT',
+            headers,
+            body: typeof data === 'string' ? data : data,
+        });
+        if (!response.ok)
+            throw await failureOf(response);
+        const body = (await response.json());
+        return body;
+    }
+    /**
+     * Several files as one transaction (plan §C.4). A refusal names the file in `failure.path`;
+     * nothing was written then.
+     */
+    async writeChangeset(entries, options = {}) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (options.mutationId)
+            headers['X-Mutation-Id'] = options.mutationId;
+        const files = entries.map(entry => ({
+            path: entry.path,
+            ...(typeof entry.data === 'string' ? { text: entry.data } : { base64: toBase64(entry.data) }),
+            ...(entry.ifMatch ? { ifMatch: entry.ifMatch } : {}),
+            ...(entry.createOnly ? { createOnly: true } : {}),
+        }));
+        const response = await this.call('changeset', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ files }),
+        });
+        if (!response.ok)
+            throw await failureOf(response);
+        return (await response.json());
+    }
+    async mkdir(path) {
+        await this.json('mkdir', { path });
+    }
+    async delete(path, options = {}) {
+        await this.json('delete', { path, recursive: options.recursive === true });
+    }
+    async move(from, to, options = {}) {
+        await this.json('move', { from, to, overwrite: options.overwrite === true });
+    }
+    async manifest() {
+        const response = await this.call('manifest');
+        if (!response.ok)
+            throw await failureOf(response);
+        return (await response.json());
+    }
+    async hash(paths) {
+        const body = await this.json('hash', { paths });
+        return body.hashes;
+    }
+    url(path) {
+        return `${this.caller.base}${path.split('/').map(encodeURIComponent).join('/')}`;
+    }
+}