@volter/world-core 2.0.0

package/dist/src/ancestry.js

@@ -0,0 +1,238 @@
+// Local branches pin parent storage. This is lifecycle authority, not a disposable cache.
+import { canonicalJson } from "./hash.js";
+import { createHash, randomUUID } from 'node:crypto';
+import { volterHome } from "./volter-home.js";
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { stateDirName } from "./storage.js";
+import { getActiveWorldStore } from "./world-store.js";
+let entered;
+export const canonicalStatePath = (path) => getActiveWorldStore().canonicalPath?.(path) ?? resolve(path);
+const metaPath = (dir) => join(dir, 'ancestry.json');
+const inside = (base, path) => { const rel = relative(canonicalStatePath(base), canonicalStatePath(path)); return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !rel.startsWith(sep)); };
+/** Synchronous only; use exclusive acquisition without age-stealing a live owner.
+ * The coordinator lives outside service, instance and hosted World deletion trees. */
+export function withAncestryLock(fn) {
+    const store = getActiveWorldStore();
+    const active = entered ??= new WeakSet();
+    if (active.has(store))
+        return fn();
+    const path = join(volterHome(), 'branch-ancestry.lock');
+    return store.withLock(path, () => {
+        active.add(store);
+        try {
+            recoverRemovals();
+            return fn();
+        }
+        finally {
+            active.delete(store);
+        }
+    }, { retainLiveOwner: true });
+}
+function metadata(dir) {
+    const raw = getActiveWorldStore().read(metaPath(dir));
+    if (raw === null)
+        return null;
+    const value = JSON.parse(raw);
+    if (!value || typeof value.generation !== 'string' || !Array.isArray(value.children)
+        || value.children.some(p => typeof p.child !== 'string' || !Number.isInteger(p.ownerPid) || p.ownerPid <= 0)) {
+        throw new Error(`Unreadable branch ancestry at ${dir}; retained`);
+    }
+    return value;
+}
+/** Create an identity only for an existing parent. A recreated path gets a new identity. */
+export function stateGeneration(dir) {
+    return withAncestryLock(() => {
+        const store = getActiveWorldStore();
+        if (!store.stat(dir)?.isDirectory)
+            throw new Error(`Branch parent is missing: ${dir}`);
+        assertNotBeingRemoved(dir);
+        let meta = metadata(dir);
+        if (!meta) {
+            meta = { generation: randomUUID(), children: [] };
+            store.writeAtomic(metaPath(dir), JSON.stringify(meta));
+        }
+        return meta.generation;
+    });
+}
+/** Must be called in the same critical section as child pointer publication. A crash before
+ * publication leaves a pending pin; it can be ignored only once its writer is provably dead. */
+export function pinParent(parentDir, child, expected) {
+    parentDir = canonicalStatePath(parentDir);
+    child = canonicalStatePath(child);
+    const generation = stateGeneration(parentDir);
+    if (expected !== undefined && generation !== expected)
+        throw new Error(`Branch parent generation changed: ${parentDir}`);
+    const meta = metadata(parentDir);
+    if (!meta.children.some(p => p.child === child)) {
+        meta.children.push({ child, ownerPid: process.pid });
+        getActiveWorldStore().writeAtomic(metaPath(parentDir), JSON.stringify(meta));
+    }
+    return generation;
+}
+/** Mark publication complete only after branch.json exists. */
+export function commitParentPin(parentDir, child) {
+    parentDir = canonicalStatePath(parentDir);
+    child = canonicalStatePath(child);
+    const meta = metadata(parentDir);
+    const pin = meta.children.find(p => p.child === child);
+    pin.committed = true;
+    getActiveWorldStore().writeAtomic(metaPath(parentDir), JSON.stringify(meta));
+}
+/** Read-only identity validation. */
+export function checkParent(parentDir, expected) {
+    if (!getActiveWorldStore().stat(parentDir)?.isDirectory)
+        throw new Error(`Branch parent is missing: ${parentDir}`);
+    if (expected !== undefined && metadata(parentDir)?.generation !== expected)
+        throw new Error(`Branch parent generation changed: ${parentDir}`);
+}
+function filesUnder(path) {
+    const store = getActiveWorldStore();
+    const info = store.stat(path);
+    if (info?.isSymbolicLink)
+        throw new Error(`Symbolic-link branch state retained: ${path}`);
+    if (!info?.isDirectory)
+        return [];
+    const result = [];
+    const stateSuffix = join(stateDirName(), 'world');
+    const stateService = dirname(path).endsWith(`${sep}${stateSuffix}`);
+    if (stateService && store.stat(join(path, 'views'))?.isSymbolicLink)
+        throw new Error(`Symbolic-link history views retained: ${path}`);
+    if (stateService)
+        return [...['ancestry.json', 'branch.json'].map(name => join(path, name)), ...store.list(join(path, 'views')).filter(name => /^[a-f0-9]{64}\.json$/.test(name)).map(name => join(path, 'views', name))].filter(file => {
+            const stat = store.stat(file);
+            if (stat?.isSymbolicLink)
+                throw new Error(`Symbolic-link ancestry metadata retained: ${file}`);
+            return stat !== null;
+        });
+    for (const name of store.list(path)) {
+        if (name === 'node_modules' || name === '.git')
+            continue;
+        const child = join(path, name);
+        if (store.stat(child)?.isSymbolicLink)
+            continue; // recursive removal unlinks this entry; its target survives
+        if (store.stat(child)?.isDirectory)
+            result.push(...filesUnder(child));
+    }
+    return result;
+}
+/** Caller holds the coordinator through the actual deletion. A committed pin with missing
+ * child metadata is uncertainty, not permission: only explicit child removal releases it. */
+export function assertStateRemovable(path) {
+    const store = getActiveWorldStore();
+    for (const file of filesUnder(path).filter(f => f.endsWith(`${sep}ancestry.json`))) {
+        const meta = metadata(dirname(file));
+        for (const pin of meta.children) {
+            if (inside(path, pin.child))
+                continue; // deleting the entire dependent subtree together
+            const raw = store.read(pin.child);
+            if (raw === null) {
+                if (!pin.committed) {
+                    try {
+                        process.kill(pin.ownerPid, 0);
+                    }
+                    catch (error) {
+                        if (error.code === 'ESRCH')
+                            continue;
+                    }
+                }
+                throw new Error(`Retained branch parent: dependent branch metadata unavailable at ${pin.child}`);
+            }
+            const retained = JSON.parse(raw);
+            if (retained.dependencies !== undefined) {
+                if (createHash('sha256').update(canonicalJson(retained)).digest('hex') + '.json' !== basename(pin.child))
+                    throw new Error(`Invalid retained history ownership ${pin.child}`);
+                if (!Array.isArray(retained.dependencies) || retained.dependencies.some(d => typeof d.directory !== 'string' || typeof d.generation !== 'string'))
+                    throw new Error(`Unreadable retained history ${pin.child}`);
+                if (retained.dependencies.some(d => canonicalStatePath(d.directory) === canonicalStatePath(dirname(file))))
+                    throw new Error(`Retained branch parent: dependent history view ${pin.child}`);
+                continue;
+            }
+            const child = JSON.parse(raw);
+            if (!child || !child.parent || typeof child.parent.at !== 'string' || !Number.isInteger(child.parent.position) || Number(child.parent.position) < 0
+                || (child.parent.generation !== undefined && typeof child.parent.generation !== 'string'))
+                throw new Error(`Unreadable dependent branch ${pin.child}; retained`);
+            if (/^[a-z][a-z0-9+.-]*:\/\//i.test(child.parent.at))
+                continue;
+            // The pin's child state layout is <control>/<stateDir>/world/<service>/branch.json.
+            // Derive the real parent from at, never trust an independently edited directory field.
+            const layout = join(stateDirName(), 'world', basename(dirname(pin.child)));
+            const actualParent = canonicalStatePath(join(child.parent.at, layout));
+            if (actualParent === canonicalStatePath(dirname(file)) || !child.parent.generation
+                || child.parent.directory !== actualParent || metadata(actualParent)?.generation !== child.parent.generation) {
+                throw new Error(`Retained branch parent: dependent branch ${pin.child}. Remove dependent branches first; down without purge can still stop compute.`);
+            }
+        }
+    }
+}
+const removalDir = () => join(volterHome(), 'branch-removals');
+function releaseOutgoing(removal) {
+    const store = getActiveWorldStore();
+    for (const { child, parent } of removal.outgoing) {
+        if (!inside(removal.path, child))
+            throw new Error('Invalid branch removal receipt; retained');
+        if (!parent?.directory || inside(removal.path, parent.directory))
+            continue;
+        const meta = metadata(parent.directory);
+        if (!meta || meta.generation !== parent.generation)
+            continue;
+        meta.children = meta.children.filter(p => p.child !== child);
+        store.writeAtomic(metaPath(parent.directory), JSON.stringify(meta));
+    }
+}
+/** A crash after deleting files cannot strand committed child pins. Receipts are replayed
+ * before any subsequent ancestry publication, so path reuse cannot hide completed removal. */
+function recoverRemovals() {
+    const store = getActiveWorldStore();
+    const pending = [];
+    for (const name of store.list(removalDir()).filter(n => n.endsWith('.json'))) {
+        const file = join(removalDir(), name);
+        const removal = JSON.parse(store.read(file));
+        if (typeof removal.path !== 'string' || !Array.isArray(removal.outgoing))
+            throw new Error('Invalid branch removal receipt; retained');
+        if (!store.exists(removal.path)) {
+            releaseOutgoing(removal);
+            store.remove(file);
+        }
+        else
+            pending.push(removal.path);
+    }
+    beingRemoved = pending;
+}
+/** State whose removal is recorded and not yet complete: its deletion runs outside the coordinator, so nothing may pin
+ * it as a parent or write into it meanwhile. Read under the coordinator, where recoverRemovals has just refreshed it. */
+let beingRemoved = [];
+export function assertNotBeingRemoved(path) {
+    const at = beingRemoved.find((p) => inside(p, path));
+    if (at)
+        throw new Error(`World state is being removed: ${at}`);
+}
+/** force on scrub bypasses shape checking only, never another branch's ownership. The coordinator is held to decide
+ * and record the removal (`check`, the caller's own precondition, runs there too) and to release it, not through the
+ * deletion: every World on the machine shares the coordinator, and a large tree's deletion outlasts their writes'
+ * patience. The receipt, written first, keeps the path from being pinned or written while it is deleted. */
+export function withStateRemoval(path, remove, check) {
+    const store = getActiveWorldStore();
+    const { removal, receipt } = withAncestryLock(() => {
+        check?.();
+        assertStateRemovable(path);
+        const outgoing = filesUnder(path).filter(f => !f.endsWith(`${sep}ancestry.json`)).flatMap(child => {
+            const branch = JSON.parse(store.read(child));
+            return (branch.dependencies ?? [...(branch.previousParents ?? []), branch.parent]).map(parent => ({ child: canonicalStatePath(child), parent }));
+        });
+        const removal = { path: canonicalStatePath(path), outgoing };
+        const receipt = join(removalDir(), `${randomUUID()}.json`);
+        store.writeAtomic(receipt, JSON.stringify(removal));
+        beingRemoved = [...beingRemoved, removal.path];
+        return { removal, receipt };
+    });
+    const result = remove();
+    withAncestryLock(() => {
+        if (store.exists(path))
+            throw new Error(`Branch state removal incomplete: ${path}; receipt retained`);
+        // Another process's recovery may have released it already; both steps are idempotent.
+        releaseOutgoing(removal);
+        if (store.exists(receipt))
+            store.remove(receipt);
+    });
+    return result;
+}

package/dist/src/args.d.ts

@@ -0,0 +1,3 @@
+/** Value of `--name <value>`; fallback when the flag is absent or has no value. */
+export declare function optionValue(args: string[], name: string, fallback?: string): string;
+export declare function hasFlag(args: string[], name: string): boolean;

package/dist/src/args.js

@@ -0,0 +1,12 @@
+// Shared CLI argument helpers for world scripts and tools. Scripts kept
+// growing private copies of these (5 in the sync subsystem alone before this
+// file); a parsing fix that lands in one copy and not the others corrupts
+// flag handling silently.
+/** Value of `--name <value>`; fallback when the flag is absent or has no value. */
+export function optionValue(args, name, fallback = '') {
+    const index = args.indexOf(name);
+    return index >= 0 && index + 1 < args.length ? args[index + 1] : fallback;
+}
+export function hasFlag(args, name) {
+    return args.includes(name);
+}

package/dist/src/blob-store.d.ts

@@ -0,0 +1,55 @@
+export interface BlobStore {
+    /** Bytes at `key`, or null when absent. Never throws for a missing key. */
+    get(key: string): Promise<Uint8Array | null>;
+    /** Store bytes at `key`, atomically (a reader never observes a torn blob). Creating
+     *  parent "directories" is the store's job; idempotent overwrite is allowed (content-
+     *  addressed callers never rewrite different bytes under one key). */
+    put(key: string, bytes: Uint8Array): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    /** Remove the blob (or, for a prefix ending in '/', everything under it — namespace
+     *  reset uses this). A missing key is not an error. */
+    remove(key: string): Promise<void>;
+    /** Keys currently stored under `prefix` (full keys, sorted). Lifecycle/reset tooling
+     *  only — the serve path addresses blobs by exact key. */
+    list(prefix: string): Promise<string[]>;
+    /** Byte size at `key`, or null when absent. */
+    size(key: string): Promise<number | null>;
+    /** Bytes `start`..`endInclusive` at `key` (clamped to the blob), or null when absent — a native
+     *  ranged read, so serving a range of a large blob (a video a player seeks in) does not load it
+     *  whole. Optional: `readBlobRange` falls back to `get` (a whole read) for a backend without it —
+     *  the hosted World's R2 store today. */
+    getRange?(key: string, start: number, endInclusive: number): Promise<Uint8Array | null>;
+}
+/** A range of the blob at `key` through the active store: native when the store has it, else sliced. */
+export declare function readBlobRange(key: string, start: number, endInclusive: number): Promise<Uint8Array | null>;
+/** Today's layout, verbatim: keys are filesystem paths. */
+export declare class FsBlobStore implements BlobStore {
+    private options;
+    constructor(options?: {
+        sharedIndexRoot?: string | false;
+    });
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, bytes: Uint8Array): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    remove(key: string): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+    size(key: string): Promise<number | null>;
+    getRange(key: string, start: number, endInclusive: number): Promise<Uint8Array | null>;
+}
+/** In-memory backend — tests and hydration rehearsals; also the shape an R2/S3 adapter
+ *  implements (same interface, object keys instead of paths). */
+export declare class MemoryBlobStore implements BlobStore {
+    private blobs;
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, bytes: Uint8Array): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    remove(key: string): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+    size(key: string): Promise<number | null>;
+    getRange(key: string, start: number, endInclusive: number): Promise<Uint8Array | null>;
+}
+/** Content-address helper shared by byte-carrying packs: sha256 hex of the bytes. */
+export declare function blobDigest(bytes: Uint8Array): string;
+export declare function getActiveBlobStore(): BlobStore;
+export declare function setActiveBlobStore(store: BlobStore): BlobStore;
+export declare function withBlobStore<T>(store: BlobStore, fn: () => Promise<T> | T): Promise<T>;

package/dist/src/blob-store.js

@@ -0,0 +1,186 @@
+// THE BLOB SEAM (runtime contract R11) — byte storage behind every handler that touches
+// raw bytes (slack file uploads, jira attachments), so a serverless namespace can put its
+// bytes in object storage while local worlds keep today's on-disk layout unchanged.
+//
+// Why bytes get their OWN seam instead of riding WorldStore: WorldStore is string-typed by
+// design (JSONL rows, JSON sidecars — the hydrate/flush snapshot is a path→string map), and
+// blob bytes must never enter that snapshot: they can be large, they never participate in
+// preconditions or projection, and they are served/accepted at the edge. Blob KEYS live in
+// string state; bytes live here. That separation is what keeps namespace snapshots small
+// enough for a Durable Object's memory (runtime contract R11–R14).
+//
+// ASYNC-NATIVE, unlike WorldStore: the sync kernel never reads blobs mid-projection — bytes
+// are read/written at the request edge (upload accept, download serve), which is already
+// async in every server. So there is no hydrate-whole-namespace step for blobs and no sync
+// constraint to honor: an R2/S3 adapter implements this interface directly, per request.
+//
+// Keys are PATHS (the FsWorldStore convention): the fs backend uses them verbatim on disk,
+// so packs keep computing today's exact layout (…/resources/blobs/sha256/<ab>/<hex>) and
+// local worlds change NOTHING — scrub, backup, and inspection all still see the same tree.
+// A remote adapter maps the path to an object key (namespace prefix + path).
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { volterHome } from "./volter-home.js";
+import { sharedBlobIndex } from "./shared-blob-index.js";
+/** A range of the blob at `key` through the active store: native when the store has it, else sliced. */
+export async function readBlobRange(key, start, endInclusive) {
+    // one clamping for every backend: a negative or non-finite start reads from 0, a range that ends
+    // before it begins is empty (subarray alone would count negatives from the end)
+    const from = Number.isFinite(start) ? Math.max(0, Math.floor(start)) : 0;
+    const to = Number.isFinite(endInclusive) ? Math.floor(endInclusive) : -1;
+    const store = getActiveBlobStore();
+    if (to < from)
+        return (await store.exists(key)) ? new Uint8Array(0) : null;
+    if (store.getRange)
+        return store.getRange(key, from, to);
+    const whole = await store.get(key);
+    return whole === null ? null : whole.subarray(from, to + 1);
+}
+/** Today's layout, verbatim: keys are filesystem paths. */
+export class FsBlobStore {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async get(key) {
+        if (!existsSync(key))
+            return null;
+        return new Uint8Array(readFileSync(key));
+    }
+    async put(key, bytes) {
+        mkdirSync(dirname(key), { recursive: true });
+        // Write-then-rename so a crash mid-write never leaves a truncated blob that a
+        // content-addressed caller would forever report as present (the slack-blobs rule,
+        // now the seam's rule).
+        const tmp = `${key}.tmp.${randomUUID()}`;
+        let index;
+        try {
+            if (this.options.sharedIndexRoot !== false) {
+                try {
+                    index = sharedBlobIndex(this.options.sharedIndexRoot ?? join(volterHome(), 'blob-index-v1'), statSync(dirname(key)).dev, blobDigest(bytes));
+                }
+                catch { /* The index is an optimization, never a prerequisite for a blob write. */ }
+            }
+            if (!index?.reuse(tmp, bytes.byteLength))
+                writeFileSync(tmp, bytes, { flag: 'wx' });
+            renameSync(tmp, key);
+            index?.record(key);
+        }
+        finally {
+            rmSync(tmp, { force: true });
+        }
+    }
+    async exists(key) {
+        return existsSync(key);
+    }
+    async remove(key) {
+        rmSync(key, { force: true, recursive: key.endsWith('/') });
+    }
+    async list(prefix) {
+        const out = [];
+        const walk = (dir) => {
+            if (!existsSync(dir))
+                return;
+            for (const name of readdirSync(dir, { withFileTypes: true })) {
+                const child = join(dir, name.name);
+                if (name.isDirectory())
+                    walk(child);
+                else if (!name.name.includes('.tmp.'))
+                    out.push(child);
+            }
+        };
+        walk(prefix.replace(/\/$/, ''));
+        return out.sort();
+    }
+    async size(key) {
+        if (!existsSync(key))
+            return null;
+        return statSync(key).size;
+    }
+    async getRange(key, start, endInclusive) {
+        if (!existsSync(key))
+            return null;
+        const total = statSync(key).size;
+        const from = Math.max(0, start), to = Math.min(endInclusive, total - 1);
+        if (to < from)
+            return new Uint8Array(0);
+        const out = new Uint8Array(to - from + 1);
+        const fd = openSync(key, 'r');
+        let read = 0;
+        try {
+            while (read < out.length) {
+                const n = readSync(fd, out, read, out.length - read, from + read);
+                if (n === 0)
+                    break;
+                read += n;
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+        return read === out.length ? out : out.subarray(0, read);
+    }
+}
+/** In-memory backend — tests and hydration rehearsals; also the shape an R2/S3 adapter
+ *  implements (same interface, object keys instead of paths). */
+export class MemoryBlobStore {
+    blobs = new Map();
+    async get(key) {
+        const bytes = this.blobs.get(key);
+        return bytes === undefined ? null : new Uint8Array(bytes);
+    }
+    async put(key, bytes) {
+        this.blobs.set(key, new Uint8Array(bytes));
+    }
+    async exists(key) {
+        return this.blobs.has(key);
+    }
+    async remove(key) {
+        if (key.endsWith('/')) {
+            for (const k of [...this.blobs.keys()])
+                if (k.startsWith(key))
+                    this.blobs.delete(k);
+        }
+        else
+            this.blobs.delete(key);
+    }
+    async list(prefix) {
+        return [...this.blobs.keys()].filter((k) => k.startsWith(prefix.replace(/\/$/, ''))).sort();
+    }
+    async size(key) {
+        return this.blobs.get(key)?.length ?? null;
+    }
+    async getRange(key, start, endInclusive) {
+        const bytes = this.blobs.get(key);
+        if (bytes === undefined)
+            return null;
+        const from = Number.isFinite(start) ? Math.max(0, Math.floor(start)) : 0;
+        const to = Number.isFinite(endInclusive) ? Math.floor(endInclusive) : -1;
+        return to < from ? new Uint8Array(0) : new Uint8Array(bytes.subarray(from, to + 1));
+    }
+}
+/** Content-address helper shared by byte-carrying packs: sha256 hex of the bytes. */
+export function blobDigest(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+// Active-store scoping, the world-store.ts pattern exactly: default fs; a serverless entry
+// (or a test) swaps in its adapter for the scope of a request.
+let activeBlobStore = new FsBlobStore();
+export function getActiveBlobStore() {
+    return activeBlobStore;
+}
+export function setActiveBlobStore(store) {
+    const previous = activeBlobStore;
+    activeBlobStore = store;
+    return previous;
+}
+export async function withBlobStore(store, fn) {
+    const previous = setActiveBlobStore(store);
+    try {
+        return await fn();
+    }
+    finally {
+        setActiveBlobStore(previous);
+    }
+}

package/dist/src/brand-tokens.d.ts

@@ -0,0 +1,2 @@
+/** Serve `<base>/brand/<rest>` from `dir`: `tokens.css` or `fonts/<face>`; 404 for any other name or a file the build did not write. */
+export declare function brandTokensResponse(dir: string, rest: string): Response;

package/dist/src/brand-tokens.js

@@ -0,0 +1,17 @@
+// Serving the Volter brand's tokens and faces (company decision 0018) from a page's own base, like
+// fileResponse (the serve seam's helpers, docs/contributing/architecture.md#the-serve-seam). The files
+// are written at build by scripts/brand-tokens.ts into the page's gitignored `brand/` directory; this
+// only reads them and never fetches, so a running world does not reach the brand.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileResponse } from "./file-response.js";
+const FONT_TYPES = { woff2: 'font/woff2', woff: 'font/woff', ttf: 'font/ttf', otf: 'font/otf' };
+/** Serve `<base>/brand/<rest>` from `dir`: `tokens.css` or `fonts/<face>`; 404 for any other name or a file the build did not write. */
+export function brandTokensResponse(dir, rest) {
+    const font = /^fonts\/[A-Za-z0-9_.-]+\.(woff2|woff|ttf|otf)$/.exec(rest);
+    if (rest !== 'tokens.css' && !font)
+        return new Response('not found', { status: 404 });
+    if (!existsSync(join(dir, 'tokens.css')))
+        return new Response('the brand tokens are not built here; run `bun scripts/brand-tokens.ts`', { status: 404 });
+    return fileResponse(join(dir, rest), { headers: { 'cache-control': 'no-cache', 'content-type': font ? FONT_TYPES[font[1]] : 'text/css; charset=utf-8' } });
+}