Made of little things.

// Self-contained example backend. Nothing here is built into the provider.
// State values are validated against the adjacent schemas before commit.
type Context = {
    operation: string;
    principal: string;
    account: string | null;
    instance: string;
    release: string;
    owner: string;
    state: {
        get(collection: string, key: string): Promise<any>;
        set(collection: string, key: string, value: unknown): Promise<unknown>;
        access(): Promise<any>;
        setAccess(value: unknown): Promise<unknown>;
        setMember(principal: string, role: string | null): Promise<unknown>;
    };
};
const palette = ['air', 'stone', 'dirt', 'grass', 'wood', 'glass', 'sand', 'water'];
function key(position: { x: number; y: number; z: number }) {
    return `${position.x},${position.y},${position.z}`;
}
async function chunk(ctx: Context, position: { x: number; y: number; z: number }) {
    return (
        (await ctx.state.get('chunks', key(position))) ?? {
            position,
            revision: 0,
            blocks: Array(512).fill(0),
        }
    );
}
async function inventory(ctx: Context) {
    if (!ctx.account) throw new Error('ACCOUNT_REQUIRED: Survival inventory requires an account.');
    return (
        (await ctx.state.get('inventories', ctx.principal)) ?? {
            revision: 0,
            blocks: [64, 64, 64, 64, 64, 64, 64],
        }
    );
}
export async function handle(ctx: Context, input: any): Promise<Record<string, unknown>> {
    if (ctx.operation === 'createWorld') {
        if (
            input.guestsMayBuild &&
            (input.mode !== 'creative' ||
                input.visibility !== 'public' ||
                input.building !== 'everyone')
        )
            throw new Error(
                'BAD_INPUT: Guest building requires a public creative world open to everyone.',
            );
        await ctx.state.setAccess({
            visibility: input.visibility,
            building: input.building,
            guestsMayBuild: input.guestsMayBuild,
            members: {},
        });
        await ctx.state.set('worlds', 'meta', {
            name: input.name,
            seed: input.seed,
            mode: input.mode,
            owner: ctx.principal,
            release: ctx.release,
        });
        if (input.terrain === 'island') {
            // Four bounded chunks form the demo's initial island. Saved once, by the
            // same transaction as creation; clients never synthesize authoritative land.
            for (let cx = 0; cx < 2; cx++)
                for (let cz = 0; cz < 2; cz++) {
                    const record = await chunk(ctx, { x: cx, y: 0, z: cz });
                    for (let x = 0; x < 8; x++)
                        for (let z = 0; z < 8; z++) {
                            const wx = cx * 8 + x,
                                wz = cz * 8 + z;
                            const distance = Math.hypot(wx - 7.5, wz - 7.5);
                            const shore = 6.5 + Math.sin(wx * 1.7 + input.seed) * 0.5;
                            const height = distance < 3.5 ? 3 : distance < shore ? 2 : 1;
                            for (let y = 0; y < height; y++)
                                record.blocks[x + 8 * (z + 8 * y)] =
                                    y < height - 1
                                        ? 1
                                        : distance < shore - 1
                                          ? 3
                                          : distance < shore
                                            ? 6
                                            : 7;
                            // A little tree in the corner leaves the central building site clear.
                            if (wx === 4 && wz === 4)
                                for (let y = height; y < height + 3; y++)
                                    record.blocks[x + 8 * (z + 8 * y)] = 4;
                            if (Math.abs(wx - 4) <= 1 && Math.abs(wz - 4) <= 1)
                                record.blocks[x + 8 * (z + 8 * 5)] = 3;
                        }
                    record.revision = 1;
                    await ctx.state.set('chunks', key(record.position), record);
                }
        }
        return { world: ctx.instance };
    }
    const world = await ctx.state.get('worlds', 'meta');
    if (!world) throw new Error('BAD_INPUT: World metadata is missing.');
    if (ctx.operation === 'readWorld') return world;
    if (ctx.operation === 'readChunks') {
        const chunks = [];
        for (const position of input.positions) chunks.push(await chunk(ctx, position));
        return { chunks };
    }
    if (ctx.operation === 'readMyInventory') return inventory(ctx);
    if (ctx.operation === 'setMember') {
        await ctx.state.setMember(input.principal, input.role === 'remove' ? null : input.role);
        return { changed: true };
    }
    if (!['placeBlock', 'removeBlock'].includes(ctx.operation))
        throw new Error('BAD_INPUT: Unknown game command.');
    const position = {
        x: Math.floor(input.x / 8),
        y: Math.floor(input.y / 8),
        z: Math.floor(input.z / 8),
    };
    const record = await chunk(ctx, position);
    if (record.revision !== input.expectedChunkRevision)
        throw new Error('CONFLICT: Chunk changed. Refresh it before trying again.');
    const offset = (input.x % 8) + 8 * ((input.z % 8) + 8 * (input.y % 8));
    const before = record.blocks[offset];
    const after = ctx.operation === 'placeBlock' ? palette.indexOf(input.block) : 0;
    if (ctx.operation === 'placeBlock' && before !== 0)
        throw new Error('CONFLICT: There is already a block here.');
    if (ctx.operation === 'removeBlock' && before === 0)
        throw new Error('CONFLICT: This cell is already empty.');
    if (world.mode === 'survival') {
        const bag = await inventory(ctx),
            slot = (ctx.operation === 'placeBlock' ? after : before) - 1;
        if (ctx.operation === 'placeBlock' && bag.blocks[slot] <= 0)
            throw new Error('FORBIDDEN: You do not have that block in your inventory.');
        bag.blocks[slot] += ctx.operation === 'placeBlock' ? -1 : 1;
        bag.revision++;
        await ctx.state.set('inventories', ctx.principal, bag);
    }
    record.blocks[offset] = after;
    record.revision++;
    await ctx.state.set('chunks', key(position), record);
    return { chunkRevision: record.revision };
}