@adukilabs/sdk 0.1.1 → 0.1.2

package/dist/dpop.js

@@ -0,0 +1,156 @@
+// DPoP (RFC 9449; ADK-AUTH-001 section 10, aduki-kt Dpop.kt) with ES256 and a
+// non-extractable WebCrypto P-256 key. The private key never leaves the
+// key store: it can only sign. It is persisted as a CryptoKey in IndexedDB
+// (or any storage that structured-clones keys), or kept in memory only.
+//
+// - A request with no Authorization (sign-in, refresh) gets a proof without `ath`.
+// - A request whose token is bound to this key (`cnf.jkt` equals the thumbprint)
+//   is sent as `Authorization: DPoP <token>` with a proof carrying `ath`.
+// - Any other credential is left untouched.
+// - A DPoP-Nonce from the server is remembered per origin; a 401 or 400
+//   carrying a nonce is retried once with it.
+import { claims, encode, encodeText } from './base64.js';
+import { ProtocolError } from './errors.js';
+const ALG = { name: 'ECDSA', namedCurve: 'P-256' };
+const KEY = 'dpop.key';
+export class Dpop {
+    #pair;
+    #jwk;
+    #thumbprint;
+    #clock;
+    #nonces = new Map();
+    /** Use `Dpop.load` or `Dpop.generate`. */
+    constructor(pair, jwk, thumbprint, clock = Date.now) {
+        this.#pair = pair;
+        this.#jwk = jwk;
+        this.#thumbprint = thumbprint;
+        this.#clock = clock;
+    }
+    /** Generates a new non-extractable key. */
+    static async generate(options = {}) {
+        const pair = await globalThis.crypto.subtle.generateKey(ALG, false, ['sign', 'verify']);
+        return Dpop.from(pair, options);
+    }
+    /** Wraps an existing key pair (its private key must be a P-256 ECDSA signing key). */
+    static async from(pair, options = {}) {
+        const exported = await globalThis.crypto.subtle.exportKey('jwk', pair.publicKey);
+        const jwk = { kty: 'EC', crv: 'P-256', x: exported.x, y: exported.y };
+        return new Dpop(pair, jwk, await thumbprint(jwk), options.clock);
+    }
+    /**
+     * Loads the key from `storage` (key `dpop.key`), or generates and saves one.
+     * Two tabs loading at the same time must end with the same key, so the
+     * read-or-create runs under a Web Lock when the browser has one (a key made by
+     * a tab that lost the race would otherwise be overwritten and its tokens
+     * bound to a key nobody holds any more).
+     */
+    static async load(storage, options = {}) {
+        const locks = options.locks === undefined ? globalThis.navigator?.locks : options.locks;
+        const once = async () => {
+            const saved = await storage.get(KEY);
+            if (saved?.privateKey && saved?.publicKey)
+                return Dpop.from(saved, options);
+            const made = await Dpop.generate(options);
+            await storage.set(KEY, made.#pair);
+            return made;
+        };
+        return locks ? locks.request('aduki-dpop-key', once) : once();
+    }
+    /** The key's thumbprint (RFC 7638), as stored by Aduki ID in `cnf.jkt`. */
+    get thumbprint() {
+        return this.#thumbprint;
+    }
+    /** The public JWK (kty, crv, x, y). */
+    get jwk() {
+        return { ...this.#jwk };
+    }
+    /**
+     * One proof for `method` on `url` (query and fragment are not signed). Pass
+     * `access` to bind the proof to a token with `ath`, and `nonce` when the
+     * server asked for one.
+     */
+    proof({ method, url, access = null, nonce = null }) {
+        return this.sign({ htm: method.toUpperCase(), htu: String(url).split('#')[0].split('?')[0], access, nonce });
+    }
+    /**
+     * One proof with `htm` and `htu` exactly as given (no upper-casing, no URL
+     * trimming), for proofs outside HTTP: the Chats handshake signs
+     * `htm = "ae09"`, `htu = "identity.response"` with the challenge as `nonce`.
+     */
+    async sign({ htm, htu, access = null, nonce = null }) {
+        const header = { typ: 'dpop+jwt', alg: 'ES256', jwk: this.#jwk };
+        const body = {
+            htm,
+            htu,
+            iat: Math.floor(this.#clock() / 1000),
+            jti: encode(globalThis.crypto.getRandomValues(new Uint8Array(16))),
+        };
+        if (access)
+            body.ath = await athash(access);
+        if (nonce)
+            body.nonce = nonce;
+        const input = `${encodeText(JSON.stringify(header))}.${encodeText(JSON.stringify(body))}`;
+        // WebCrypto ECDSA returns the raw r||s form that JWS ES256 uses.
+        const signature = await globalThis.crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, this.#pair.privateKey, new TextEncoder().encode(input));
+        return `${input}.${encode(signature)}`;
+    }
+    /**
+     * Returns `request` with its DPoP header and scheme applied by the rules above.
+     * @param nonce defaults to the one remembered for the origin
+     */
+    async apply(request, nonce = this.#nonces.get(new URL(request.url).origin) ?? null) {
+        const sent = request.headers.get('Authorization') ?? '';
+        const [scheme, token] = sent.split(' ');
+        const headers = new Headers(request.headers);
+        if (sent.trim() === '') {
+            headers.set('DPoP', await this.proof({ method: request.method, url: request.url, nonce }));
+        }
+        else if ((scheme === 'Bearer' || scheme === 'DPoP') && token && this.bound(token)) {
+            headers.set('Authorization', `DPoP ${token}`);
+            headers.set('DPoP', await this.proof({ method: request.method, url: request.url, access: token, nonce }));
+        }
+        else {
+            return request;
+        }
+        return new Request(request, { headers });
+    }
+    /** True when the access token (a JWT) is bound to this key. */
+    bound(token) {
+        return claims(token).cnf?.jkt === this.#thumbprint;
+    }
+    /** A fetch that applies DPoP and retries once on a fresh `DPoP-Nonce`. */
+    wrap(inner = (...args) => globalThis.fetch(...args)) {
+        return async (input, init) => {
+            const request = new Request(input, init);
+            const spare = request.clone();
+            const response = await inner(await this.apply(request));
+            const origin = new URL(request.url).origin;
+            const nonce = response.headers.get('DPoP-Nonce');
+            if (nonce)
+                this.#nonces.set(origin, nonce);
+            if (!nonce || (response.status !== 401 && response.status !== 400))
+                return response;
+            await response.arrayBuffer().catch(() => { });
+            const retry = await inner(await this.apply(spare, nonce));
+            const next = retry.headers.get('DPoP-Nonce');
+            if (next)
+                this.#nonces.set(origin, next);
+            return retry;
+        };
+    }
+}
+/** base64url SHA-256 of the access token (`ath`) */
+async function athash(token) {
+    return encode(await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(token)));
+}
+/** The RFC 7638 JWK thumbprint of an EC or OKP public key. */
+export async function thumbprint(jwk) {
+    let canonical;
+    if (jwk.kty === 'EC')
+        canonical = { crv: jwk.crv, kty: 'EC', x: jwk.x, y: jwk.y };
+    else if (jwk.kty === 'OKP')
+        canonical = { crv: jwk.crv, kty: 'OKP', x: jwk.x };
+    else
+        throw new ProtocolError(`Unsupported key type ${jwk.kty}`);
+    return encode(await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(JSON.stringify(canonical))));
+}

package/dist/errors.d.ts

@@ -101,6 +101,17 @@ export declare class IdentityMismatchError extends NetworkError {
     /** `subject` or `jkt.mismatch` */
     get reason(): string;
 }
+/**
+ * `403 access.denied` with `details.reason = "client"`: the route is not for
+ * a program. A workspace's service client (machine access) is refused where
+ * only a person may act: in Store shares, links, devices, reports, search,
+ * tickets and the change feed; in Space the strict and money routes. Another
+ * token does not help: the route needs a person signed in.
+ */
+export declare class ClientRefusedError extends NetworkError {
+    /** always `client` */
+    get reason(): string;
+}
 /**
  * A 2xx authentication answer that could not be used. `refresh` carries a
  * rotated refresh token the answer did include, so callers never lose a token
@@ -139,7 +150,8 @@ export interface Refused {
  * ProofError; `details.reason` `token.required`: TokenRequiredError;
  * `session.expired`, `session.ended`: SessionEndedError); a 429
  * RateLimitedError; a 403 with `details.reason` `subject` or `jkt.mismatch`
- * IdentityMismatchError; `403 auth.stepup` StepUpError;
+ * IdentityMismatchError; a 403 with `details.reason` `client`
+ * ClientRefusedError; `403 auth.stepup` StepUpError;
  * `plan.limit` and `quota.exceeded` LimitError; `sync.reset` SyncResetError;
  * a 5xx ServerError; anything else NetworkError. Every one but the 401s is a
  * NetworkError with `status`, `kind`, `details` and `retryAfter` (from the

package/dist/errors.js

@@ -108,6 +108,19 @@ export class IdentityMismatchError extends NetworkError {
         return reasonOf(this.details);
     }
 }
+/**
+ * `403 access.denied` with `details.reason = "client"`: the route is not for
+ * a program. A workspace's service client (machine access) is refused where
+ * only a person may act: in Store shares, links, devices, reports, search,
+ * tickets and the change feed; in Space the strict and money routes. Another
+ * token does not help: the route needs a person signed in.
+ */
+export class ClientRefusedError extends NetworkError {
+    /** always `client` */
+    get reason() {
+        return reasonOf(this.details);
+    }
+}
 /**
  * A 2xx authentication answer that could not be used. `refresh` carries a
  * rotated refresh token the answer did include, so callers never lose a token
@@ -131,7 +144,8 @@ export class StorageError extends AdukiError {
  * ProofError; `details.reason` `token.required`: TokenRequiredError;
  * `session.expired`, `session.ended`: SessionEndedError); a 429
  * RateLimitedError; a 403 with `details.reason` `subject` or `jkt.mismatch`
- * IdentityMismatchError; `403 auth.stepup` StepUpError;
+ * IdentityMismatchError; a 403 with `details.reason` `client`
+ * ClientRefusedError; `403 auth.stepup` StepUpError;
  * `plan.limit` and `quota.exceeded` LimitError; `sync.reset` SyncResetError;
  * a 5xx ServerError; anything else NetworkError. Every one but the 401s is a
  * NetworkError with `status`, `kind`, `details` and `retryAfter` (from the
@@ -155,6 +169,8 @@ export function refusal({ status, kind = '', message, details, retry, what }) {
         return new RateLimitedError(full, options);
     if (status === 403 && (reason === 'subject' || reason === 'jkt.mismatch'))
         return new IdentityMismatchError(full, options);
+    if (status === 403 && reason === 'client')
+        return new ClientRefusedError(full, options);
     if (kind === 'auth.stepup')
         return new StepUpError(full, options);
     if (kind === 'plan.limit' || kind === 'quota.exceeded')

package/dist/space/model.d.ts

@@ -0,0 +1,147 @@
+/** One page of a list: `next` is the cursor of the following page, null on the last. */
+export interface Page<T> {
+    items: T[];
+    next: string | null;
+}
+/** A success answer: the envelope's `data`, the HTTP status and the `ETag` (the row's version, without quotes). */
+export interface Reply<T> {
+    data: T;
+    status: number;
+    etag: string | null;
+}
+/** A task. The money fields are present only for members who may see them. */
+export interface Task {
+    id: string;
+    number: string;
+    title: string;
+    description: string | null;
+    priority: string;
+    status: string;
+    due: string | null;
+    client: {
+        id: string | null;
+        name: string | null;
+    } | null;
+    service: string | null;
+    team: string | null;
+    author: string | null;
+    assignees: unknown;
+    created: string;
+    updated: string;
+    archived: string | null;
+    billable?: boolean;
+    mode?: string | null;
+    rate?: number | null;
+    amount?: number | null;
+    minutes?: number;
+    currency?: string;
+    invoice?: string | null;
+    billed?: string | null;
+    [field: string]: unknown;
+}
+/** A check-in: work reported on a task, in minutes, waiting for review or reviewed. */
+export interface Checkin {
+    id: string;
+    task: string;
+    number: string;
+    account: string | null;
+    body: string;
+    minutes: number;
+    proof: string | null;
+    status: string;
+    reviewer: string | null;
+    note: string | null;
+    reviewed: string | null;
+    created: string;
+    [field: string]: unknown;
+}
+/** A support ticket. */
+export interface SupportTicket {
+    id: string;
+    number: string;
+    client: unknown;
+    contact: string | null;
+    assignee: string | null;
+    service: string | null;
+    node: string | null;
+    escalated: boolean;
+    task: unknown;
+    title: string;
+    status: string;
+    priority: string;
+    channel: string;
+    clock: string;
+    replied: string | null;
+    warned: string | null;
+    breached: string | null;
+    resolved: string | null;
+    closed: string | null;
+    created: string;
+    updated: string;
+    [field: string]: unknown;
+}
+/** A message of a ticket's thread; `id` is an integer (the thread is an append-only log); `internal` notes are staff only. */
+export interface Message {
+    id: number;
+    side: string;
+    author: string | null;
+    internal: boolean;
+    body: string;
+    created: string;
+    [field: string]: unknown;
+}
+/** A team of the workspace (from the Aduki ID directory). */
+export interface Team {
+    id: string;
+    name: string;
+    handle: string;
+    members: unknown;
+}
+/** A member of the workspace in the directory: name, handle and team ids. */
+export interface Member {
+    id: string;
+    name: string;
+    handle: string;
+    teams: string[];
+}
+/** An activity entry: the workspace's for `space.admin`, your own otherwise. */
+export interface Activity {
+    id: string;
+    /** who acted (hex); null for the system, or for a program of the workspace (then `kind` is `client`) */
+    account: string | null;
+    /** `client` when a program of the workspace acted (machine access); absent for a person or the system */
+    kind?: string;
+    entity: string;
+    action: string;
+    payload: unknown;
+    created: string;
+}
+/** The workspace settings (no secrets). */
+export interface Settings {
+    currency: string;
+    locale: string;
+    zone: string;
+    krapin: string | null;
+    /** hundredths of a percent */
+    vat: number;
+    brand: unknown;
+    prefixes: unknown;
+    cutoff: number;
+    keep: number;
+    desk: string | null;
+    smscountries: string[];
+    solo: boolean;
+    autopayroll: boolean;
+    caps: unknown;
+    updated: string;
+    [field: string]: unknown;
+}
+/** Search ids: read each by its own route. `source` is `typesense` or `postgres` (the fallback; `stale` if behind). */
+export interface Found {
+    items: {
+        collection: string;
+        id: string;
+    }[];
+    source: string;
+    stale: boolean;
+}

package/dist/store/blake3.d.ts

@@ -0,0 +1,4 @@
+/** The BLAKE3 hash (32 bytes) of `data`. */
+export declare function blake3(data: Uint8Array): Uint8Array;
+/** Lowercase hex of `bytes`. */
+export declare function hex(bytes: Uint8Array): string;

package/dist/store/blake3.js

@@ -0,0 +1,130 @@
+// BLAKE3 (hash mode, 32-byte output) in plain TypeScript: Store names every
+// chunk and every manifest by its BLAKE3, and WebCrypto has no BLAKE3. A
+// straight port of the reference implementation (github.com/BLAKE3-team/BLAKE3,
+// reference_impl.rs); the Store golden corpus checks it end to end.
+const IV = Uint32Array.of(0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19);
+const PERMUTATION = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8];
+const CHUNK_START = 1;
+const CHUNK_END = 2;
+const PARENT = 4;
+const ROOT = 8;
+const BLOCK = 64;
+const CHUNK = 1024;
+// One state and one message schedule reused by every compression (single-threaded).
+const state = new Uint32Array(16);
+const words = new Uint32Array(16);
+const scratch = new Uint32Array(16);
+function g(a, b, c, d, x, y) {
+    const s = state;
+    s[a] = (s[a] + s[b] + x) | 0;
+    let t = s[d] ^ s[a];
+    s[d] = (t >>> 16) | (t << 16);
+    s[c] = (s[c] + s[d]) | 0;
+    t = s[b] ^ s[c];
+    s[b] = (t >>> 12) | (t << 20);
+    s[a] = (s[a] + s[b] + y) | 0;
+    t = s[d] ^ s[a];
+    s[d] = (t >>> 8) | (t << 24);
+    s[c] = (s[c] + s[d]) | 0;
+    t = s[b] ^ s[c];
+    s[b] = (t >>> 7) | (t << 25);
+}
+/** Compresses `block` (16 words) into `cv` (8 words) in place; `out` gets the first 8 output words. */
+function compress(cv, block, counter, length, flags, out) {
+    state.set(cv.subarray(0, 8), 0);
+    state[8] = IV[0];
+    state[9] = IV[1];
+    state[10] = IV[2];
+    state[11] = IV[3];
+    state[12] = counter >>> 0;
+    state[13] = Math.floor(counter / 0x1_0000_0000) >>> 0;
+    state[14] = length;
+    state[15] = flags;
+    const m = words;
+    m.set(block);
+    for (let round = 0; round < 7; round++) {
+        g(0, 4, 8, 12, m[0], m[1]);
+        g(1, 5, 9, 13, m[2], m[3]);
+        g(2, 6, 10, 14, m[4], m[5]);
+        g(3, 7, 11, 15, m[6], m[7]);
+        g(0, 5, 10, 15, m[8], m[9]);
+        g(1, 6, 11, 12, m[10], m[11]);
+        g(2, 7, 8, 13, m[12], m[13]);
+        g(3, 4, 9, 14, m[14], m[15]);
+        if (round < 6) {
+            for (let i = 0; i < 16; i++)
+                scratch[i] = m[PERMUTATION[i]];
+            m.set(scratch);
+        }
+    }
+    for (let i = 0; i < 8; i++)
+        out[i] = state[i] ^ state[i + 8];
+}
+/** The 16 little-endian words of the 64-byte block of `data` at `offset` (zero padded). */
+function load(data, offset, length, into) {
+    if (length === BLOCK && (data.byteOffset + offset) % 4 === 0 && littleEndian) {
+        into.set(new Uint32Array(data.buffer, data.byteOffset + offset, 16));
+        return;
+    }
+    into.fill(0);
+    for (let i = 0; i < length; i++)
+        into[i >> 2] |= data[offset + i] << ((i & 3) * 8);
+}
+const littleEndian = new Uint8Array(Uint32Array.of(1).buffer)[0] === 1;
+/** The output of chunk `index` (`data[offset, offset + length)`, at most 1024 bytes). */
+function chunk(data, offset, length, index) {
+    const cv = IV.slice();
+    const block = new Uint32Array(16);
+    const blocks = Math.max(1, Math.ceil(length / BLOCK));
+    for (let b = 0; b < blocks - 1; b++) {
+        load(data, offset + b * BLOCK, BLOCK, block);
+        compress(cv, block, index, BLOCK, b === 0 ? CHUNK_START : 0, cv);
+    }
+    const last = length - (blocks - 1) * BLOCK;
+    load(data, offset + (blocks - 1) * BLOCK, last, block);
+    return { cv, block, counter: index, length: last, flags: (blocks === 1 ? CHUNK_START : 0) | CHUNK_END };
+}
+function chaining(output) {
+    const out = new Uint32Array(8);
+    compress(output.cv, output.block, output.counter, output.length, output.flags, out);
+    return out;
+}
+function parent(left, right) {
+    const block = new Uint32Array(16);
+    block.set(left, 0);
+    block.set(right, 8);
+    return { cv: IV.slice(), block, counter: 0, length: BLOCK, flags: PARENT };
+}
+/** The BLAKE3 hash (32 bytes) of `data`. */
+export function blake3(data) {
+    const chunks = Math.max(1, Math.ceil(data.length / CHUNK));
+    const stack = [];
+    for (let i = 0; i < chunks - 1; i++) {
+        let cv = chaining(chunk(data, i * CHUNK, CHUNK, i));
+        // Merge completed subtrees: one merge per trailing zero bit of the chunk count.
+        for (let total = i + 1; (total & 1) === 0; total >>= 1)
+            cv = chaining(parent(stack.pop(), cv));
+        stack.push(cv);
+    }
+    let output = chunk(data, (chunks - 1) * CHUNK, data.length - (chunks - 1) * CHUNK, chunks - 1);
+    while (stack.length > 0)
+        output = parent(stack.pop(), chaining(output));
+    const root = new Uint32Array(8);
+    compress(output.cv, output.block, 0, output.length, output.flags | ROOT, root);
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 8; i++) {
+        const w = root[i];
+        bytes[i * 4] = w & 0xff;
+        bytes[i * 4 + 1] = (w >>> 8) & 0xff;
+        bytes[i * 4 + 2] = (w >>> 16) & 0xff;
+        bytes[i * 4 + 3] = (w >>> 24) & 0xff;
+    }
+    return bytes;
+}
+/** Lowercase hex of `bytes`. */
+export function hex(bytes) {
+    let out = '';
+    for (const b of bytes)
+        out += b.toString(16).padStart(2, '0');
+    return out;
+}

package/dist/store/cdc.d.ts

@@ -0,0 +1,12 @@
+/** Minimum chunk size of a multi-chunk file (256 KiB). */
+export declare const MIN: number;
+/** Average chunk size (1 MiB). */
+export declare const AVG: number;
+/** Maximum chunk size, and the largest file that stays one chunk (4 MiB). */
+export declare const MAX: number;
+/**
+ * The length of the first chunk of `source` (`cut_gear` of fastcdc v2020
+ * with the Store parameters): at most `MAX`, all of `source` when it is at
+ * most `MIN` long.
+ */
+export declare function cut(source: Uint8Array): number;

package/dist/store/cdc.js

@@ -0,0 +1,127 @@
+// FastCDC 2020 cut points as Store cuts them (the `chunk` crate of the Store
+// repository over `fastcdc` 5.0.0 `v2020`: normalisation level 1, no seed,
+// the default gear table): a file of at most 4 MiB is one chunk, a longer one
+// is cut with minimum 256 KiB, average 1 MiB and maximum 4 MiB. The same
+// cuts as the server's mean identical content deduplicates. The 64-bit gear
+// hash runs on two 32-bit halves.
+/** Minimum chunk size of a multi-chunk file (256 KiB). */
+export const MIN = 256 * 1024;
+/** Average chunk size (1 MiB). */
+export const AVG = 1024 * 1024;
+/** Maximum chunk size, and the largest file that stays one chunk (4 MiB). */
+export const MAX = 4 * 1024 * 1024;
+// fastcdc v2020 GEAR: 256 u64 values, 16 hex digits each.
+const TABLE = '3b5d3c7d207e37dc784d68ba91123086cd52880f882e7298eacf8e4e19fdcca7c31f385dfbd1632b1d5f27001e25abe683130bde3c9ad991c4b225676e9b7649' +
+    'aa329b29e08eb499b67fcbd21e577d580027baaada2acf6be3ef2d5ac73c22260890f24d6ed312b7a809e036851d7c7ef0a6fe5e0013d81b1d026304452cec14' +
+    '03864632648e248fcdaacf3dcd92b9b4f5e012e63c1878568862f9d3821c00b6a82f7338750f6f8a1e583dc6c1cb0b6f7a3145b69743a7f1abb20fee404807eb' +
+    'b14b3cfe07b83a5db9dc27898adb9a0f3703f5e91baa62becf0bb866815f7d983d9867c41ea9dcd31be1fa65442bf22c14300da4c55631d9e698e9cbc6545c99' +
+    '4763107ec64e92a5c65821fc65696a2476196c064822f0b7485be841f3525e01f652bc9c85974ff5cad8352face9e3e92a6ed1dceb35e98ec6f483badc11680f' +
+    '3cfd8c17e9cf12f189b83c5e2ea56471ae665cfd24e392a9ec33c4e504cb89153fb9b15fc9fe7451d7fd1fd1945f219531ade0853443efd8255efc9863e1e2d2' +
+    '10eab6008d5642cf46f04863257ac804a52dc42a789a27d3daaadf9ce77af5656b479cd53d87febb6309e2d3f93db72fc5738ffbaa1ff9d66bd57f3f25af7968' +
+    '67605486d90d0a4ae14d0b9663bfbdaeb7bbd8d816eb0414def8a4f16b35a116e7932d85aaaffed608161cbae90cfd48855507beb294f08b91234ea6ffd399b2' +
+    'ad70cf4b2435f302d289a97565bc2d278e558437ffca99de96d2704b7115c0400889bbcdfc660e415e0d4e67dc92128d72a9f8917063ed97438b69d409e016e3' +
+    'df4fed8a5d8a439700f41dcf41d403f74814eb038e52603f9dafbacc58e2d651fe2f458e4be170af4457ec414df6a94006e62f1451123314bd1014d173ba92cc' +
+    'def318e25ed577609fea0de9dfca8525459de1e76c20624baeec189617e2d666126a2c06ab5a83cbb1321532360f613265421503dbb401232d67c287ea089ab3' +
+    '6c93bff5a56bd6b64ffb2036cab6d98dce7b785b1be7ad4fedb42ef6189fd163dc905288703988f6365f9c1d2c691884c640583680d99bfe3cd4624c07593ec6' +
+    '7f1ea8d85d7c5805014842d480b571490b649bcb5a828688bcd5708ed79b18f0e987c862fbd2f2f0982731671f0cd82cbaf13e8b16d8c0638ea3109cbd951bba' +
+    'd141045bfb385cad2acbc1a0af1f7d30e6444d89df03bfdfa18cc771b8188ff99834429db01c39bb214add07fe086a1f8f07c19b1f6b3ff956a297b1bf4ffe55' +
+    '94d558e493c54fc740bfc24c764552cb931a706f8a8520cb32229d322935bd522560d0f5dc4fefaf9dbcc48355969bb60fd81c3985c0b56ae03817e1560f2bda' +
+    'c1bb4f81d892b2d5b0c4864f4e28d2d73ecc49f9d9d6c26351307e99b52ba65e8af2b688da84a752f5d72523b91b20b66d95ff1ff4634806562f21555458339a' +
+    'c0ce47f889336346487823e5089b40d8e4727c7ebc6d95925a8f7277e94970bafca2f406b1c8bb505b1f8a95f1791070d304af9fc90286055440ab7fc930e748' +
+    '312d25fbca2ab5a110f4a4b234a4d57590301d55047e74733b6372886c61591e293402b77c444e06451f34a4d3e97dd73158d814d81bc57b034942425b9bda69' +
+    'e2032ff9e532d9bb62ae066b8b2179e59545e10c2f8d71d87ff7483eb2d23fc000945fcebdc98d868764bbbe99b26ca21b1ec62284c0bfc358e0fcc4f0aa362b' +
+    '5f4abefa878d458dfd74ac2f9607c519a4e3fb37df8cbfa9bf697e43cac574e586f14a3f68f4cd5324a23d076f1ce522e725cd8048868cc8bf3c729eb2464362' +
+    'd8f6cd57b3cc1ed86329e5242554157762aa688ad5ae1ac00a242566269bf845168b1a4753aca74bf789afefff2e7e3c6c3362093b6fccdb4ce8f50bd28c09b2' +
+    '006a2db95ae8aa93975b0d623c3d1a8c18605d3935338c5b5bb6f6136cad3c710f53a20701f8d8a6ab8c5ad2e7e93c6740b5ac5127acaa298c7bf63c2075895f' +
+    '78bd9f7e014a805cb2c9e9f4f9c8c032efd6049827eb91f32be459f482c16fbdd92ce0c5745aaa8c0aaa8fb298d965b92b37f92c6c803b158c54a5e94e0f0e78' +
+    '95f9b6e90c0a3032e7939faa436c7874d16bfe8f6a8a40c944982b86263fd2fae285fb39f984e583779a8df72d7619d3f2d79a8de8d5dd1ed1037354d66684e2' +
+    '004c82a4e668a8e531d40a7668b044e6d70578538bd02c11db45431078c5f482977121bb7f6a51ad73d5ccbd34eff8dde437a07d356e17cd47b2782043c95627' +
+    '9fb251413e41d49accd70b60652513d31c95b31e8a1b49b2cae73dfd1bcb4c1b34d98331b1f5b70f784e39f22338d92f18613d4a064df420f1d8dae25f0bcebe' +
+    '33f77c15ae855efc3c88b3b912eb109c956a2ec96bafeea51aa005b5e0ad0e875500d70527c4bb8ee36c57196421cc4413c4d286cc36ee395654a23d818b2a81' +
+    '77b1dc13d161abdc734f44de5f8d5eb560717e174a6c89a2d47d9649266a211e5b13a4322bb69e90f7669609f8b5fc3c21e6ac55bedcdac99b56b62b61166dea' +
+    'f48f66b939797e9c35f332f9c0e6ae9acc733f6a9a878db03da161e41cc108c2b7d74ae535914d514d493b0b11d36469ce264d1dfba9741aa9d1f2dc7436dc06' +
+    '70738016604c2a27231d36e96e93f3d57666881197838d194a2a83090aaad40cf1e761591668b35d7363236497f730a7301080e37379dd4d502dea2971827042' +
+    'c2c5eb858f32625f786afb9edfafbdffdaee0d868490b2a4617366b3268609f6ae0e35a0fe46173ed1a07de93e824f11079b8b115ea4cca893a99274558faebb' +
+    'fb1e6e22e08a03b3ea635fdba3698dd0cf53659328503a5ccde3b31e6fd5d7808e3e4221d3614413ef14d0d86bf1a22ce1d830d3f16c5ddbaabd2b2a451504e1';
+const GEAR_HI = new Uint32Array(256);
+const GEAR_LO = new Uint32Array(256);
+const LS_HI = new Uint32Array(256);
+const LS_LO = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    const hi = parseInt(TABLE.slice(i * 16, i * 16 + 8), 16) >>> 0;
+    const lo = parseInt(TABLE.slice(i * 16 + 8, i * 16 + 16), 16) >>> 0;
+    GEAR_HI[i] = hi;
+    GEAR_LO[i] = lo;
+    // GEAR_LS is GEAR shifted left one bit (wrapping), as in the crate.
+    LS_HI[i] = ((hi << 1) | (lo >>> 31)) >>> 0;
+    LS_LO[i] = (lo << 1) >>> 0;
+}
+// The masks for an average of 1 MiB at level 1: MASKS[21] (strict) and
+// MASKS[19] (relaxed), and each shifted left one bit.
+const S_HI = 0x0000d917;
+const S_LO = 0x67537000;
+const L_HI = 0x0000d917;
+const L_LO = 0x07537000;
+const SLS_HI = ((S_HI << 1) | (S_LO >>> 31)) >>> 0;
+const SLS_LO = (S_LO << 1) >>> 0;
+const LLS_HI = ((L_HI << 1) | (L_LO >>> 31)) >>> 0;
+const LLS_LO = (L_LO << 1) >>> 0;
+/**
+ * The length of the first chunk of `source` (`cut_gear` of fastcdc v2020
+ * with the Store parameters): at most `MAX`, all of `source` when it is at
+ * most `MIN` long.
+ */
+export function cut(source) {
+    let remaining = source.length;
+    if (remaining <= MIN)
+        return remaining;
+    let center = AVG;
+    if (remaining > MAX)
+        remaining = MAX;
+    else if (remaining < center)
+        center = remaining;
+    const limit1 = center >>> 1;
+    const limit2 = remaining >>> 1;
+    let index = MIN >>> 1;
+    let hi = 0;
+    let lo = 0;
+    while (index < limit1) {
+        const a = index * 2;
+        // hash = (hash << 2) + GEAR_LS[src[a]]
+        let b = source[a];
+        hi = ((hi << 2) | (lo >>> 30)) >>> 0;
+        lo = (lo << 2) >>> 0;
+        let sum = lo + LS_LO[b];
+        lo = sum >>> 0;
+        hi = (hi + LS_HI[b] + (sum > 0xffffffff ? 1 : 0)) >>> 0;
+        if ((hi & SLS_HI) === 0 && (lo & SLS_LO) === 0)
+            return a;
+        // hash = hash + GEAR[src[a + 1]]
+        b = source[a + 1];
+        sum = lo + GEAR_LO[b];
+        lo = sum >>> 0;
+        hi = (hi + GEAR_HI[b] + (sum > 0xffffffff ? 1 : 0)) >>> 0;
+        if ((hi & S_HI) === 0 && (lo & S_LO) === 0)
+            return a + 1;
+        index++;
+    }
+    while (index < limit2) {
+        const a = index * 2;
+        let b = source[a];
+        hi = ((hi << 2) | (lo >>> 30)) >>> 0;
+        lo = (lo << 2) >>> 0;
+        let sum = lo + LS_LO[b];
+        lo = sum >>> 0;
+        hi = (hi + LS_HI[b] + (sum > 0xffffffff ? 1 : 0)) >>> 0;
+        if ((hi & LLS_HI) === 0 && (lo & LLS_LO) === 0)
+            return a;
+        b = source[a + 1];
+        sum = lo + GEAR_LO[b];
+        lo = sum >>> 0;
+        hi = (hi + GEAR_HI[b] + (sum > 0xffffffff ? 1 : 0)) >>> 0;
+        if ((hi & L_HI) === 0 && (lo & L_LO) === 0)
+            return a + 1;
+        index++;
+    }
+    return remaining;
+}

package/dist/store/chunks.d.ts

@@ -0,0 +1,23 @@
+/** One chunk of a manifest: where it is in the file, its size and its BLAKE3 (64 hex digits). */
+export interface Chunk {
+    offset: number;
+    size: number;
+    hash: string;
+}
+/** A file's chunk list, its size and its manifest hash. */
+export interface Manifest {
+    size: number;
+    hash: string;
+    chunks: Chunk[];
+}
+/** Content the SDK can upload: a Blob (a File too), an ArrayBuffer or bytes. */
+export type Content = Blob | ArrayBuffer | Uint8Array;
+/** `content` as a Blob (bytes are copied once). */
+export declare function blob(content: Content): Blob;
+/** The manifest of `content`; `progress` is called with the bytes read so far. */
+export declare function manifest(content: Content, progress?: (read: number) => void): Promise<Manifest>;
+/** The manifest hash of `chunks`. */
+export declare function seal(chunks: readonly {
+    hash: string;
+    size: number;
+}[]): string;