@ultimabase/files 0.0.0-stage → 0.1.1

package/dist/plugin.d.ts

@@ -0,0 +1,39 @@
+import type { Http } from '@ultimabase/http';
+import type { CallerRule, Identity, PluginOf, PluginTypes } from 'ultimabase';
+import type { Checked } from './lifecycle.ts';
+import type { FileStorage } from './storage.ts';
+/** What `filesPlugin` takes (D-152). */
+export interface FilesOptions {
+    readonly storage: FileStorage;
+    readonly access?: {
+        /** A signed-in user by default; Master always may. */
+        readonly upload?: CallerRule;
+    };
+}
+/** The files plugin's types (D-57). */
+export interface Files extends PluginTypes {
+    readonly name: 'files';
+    readonly appOptions: FilesOptions;
+    readonly requires: Http;
+}
+/** Files for the application's file fields; it requires `httpPlugin()`. */
+export declare const filesPlugin: PluginOf<Files>;
+/** What `files.upload` takes. */
+export interface UploadArgs {
+    /** The field the file is for: `Post.cover`. */
+    readonly for: string;
+    readonly name: string;
+    readonly as?: Identity;
+}
+/** The running files plugin, from server code (D-152). */
+export declare const files: {
+    /** Stores a file as `POST /files` does, and gives its id. */
+    upload(body: Uint8Array | Blob, args: UploadArgs): Promise<{
+        readonly id: string;
+    }>;
+    /** Compares the storage's keys with `FilesBlob`. */
+    check(options?: {
+        readonly delete?: boolean;
+    }): Promise<Checked>;
+};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAE5C,OAAO,KAAK,EACX,UAAU,EAEV,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,MAAM,YAAY,CAAA;AAInB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAW7C,OAAO,KAAK,EAAY,WAAW,EAAE,MAAM,cAAc,CAAA;AAKzD,wCAAwC;AACxC,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE;QACjB,sDAAsD;QACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAA;KAC5B,CAAA;CACD;AAED,uCAAuC;AACvC,MAAM,WAAW,KAAM,SAAQ,WAAW;IACzC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAA;CACvB;AAoED,2EAA2E;AAC3E,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAqB,CAAA;AAE7D,iCAAiC;AACjC,MAAM,WAAW,UAAU;IAC1B,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAA;CACtB;AAED,0DAA0D;AAC1D,eAAO,MAAM,KAAK,EAAE;IACnB,6DAA6D;IAC7D,MAAM,CACL,IAAI,EAAE,UAAU,GAAG,IAAI,EACvB,IAAI,EAAE,UAAU,GACd,OAAO,CAAC;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACnC,oDAAoD;IACpD,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CAWhE,CAAA"}

package/dist/plugin.js

@@ -0,0 +1,80 @@
+import { httpPlugin } from '@ultimabase/http';
+import { definePlugin } from 'ultimabase';
+import manifest from '../package.json' with { type: 'json' };
+import { attach, check, deleteHeld, deleteLost, release, resolve, sweep, } from './lifecycle.js';
+import { FilesBlob } from './model.js';
+import { uploads } from './routes.js';
+import { upload } from './upload.js';
+import { runningOf, useRunning } from './values.js';
+/** Ten minutes, between two sweeps. */
+const sweepEvery = 10 * 60 * 1000;
+/** Each model's file fields, with the options `file()` checked. */
+function fieldsOf(models) {
+    const fields = new Map();
+    for (const model of models) {
+        const own = Object.entries(model.fieldTypes).flatMap(([field, type]) => type.plugin === 'files'
+            ? [[field, type.options]]
+            : []);
+        if (own.length > 0)
+            fields.set(model.schema.name, new Map(own));
+    }
+    return fields;
+}
+const signedIn = ({ caller }) => caller.kind === 'user';
+// The sweep's timer, while the application runs.
+let timer;
+/** Sweeps, then again every ten minutes; a failed sweep is logged. */
+async function sweeping() {
+    try {
+        await sweep();
+    }
+    catch (error) {
+        runningOf().logger.warn({ err: error }, 'The files sweep failed.');
+    }
+}
+const definition = definePlugin({
+    name: 'files',
+    manifest,
+    requires: { http: httpPlugin },
+    models: [FilesBlob],
+    api: ({ plugins }) => {
+        plugins.http.mount(uploads(), { bodyLimit: false });
+    },
+    hooks: {
+        beforeCreate: (facts) => resolve(facts),
+        beforeUpdate: (facts) => resolve(facts),
+        afterCreate: (facts) => attach(facts),
+        afterUpdate: (facts) => attach(facts),
+        afterDelete: (facts) => release(facts),
+        afterUpdateCommit: (facts) => deleteLost(facts),
+        afterDeleteCommit: (facts) => deleteHeld(facts),
+    },
+    start: async ({ options, models, logger }) => {
+        const { storage, access } = options;
+        storage.start();
+        const fields = fieldsOf(models);
+        useRunning({ storage, upload: access?.upload ?? signedIn, fields, logger });
+        await sweeping();
+        timer = setInterval(() => void sweeping(), sweepEvery);
+        timer.unref();
+    },
+    stop: () => {
+        clearInterval(timer);
+        timer = undefined;
+        useRunning(undefined);
+    },
+});
+/** Files for the application's file fields; it requires `httpPlugin()`. */
+export const filesPlugin = definition.plugin;
+/** The running files plugin, from server code (D-152). */
+export const files = {
+    upload: (body, args) => {
+        const given = body instanceof Uint8Array ? body : body.stream();
+        const type = body instanceof Uint8Array ? undefined : body.type;
+        return upload(given, body instanceof Uint8Array ? body.length : body.size, {
+            ...args,
+            type,
+        });
+    },
+    check: (options) => check(options),
+};

package/dist/routes.d.ts

@@ -0,0 +1,4 @@
+import type { Routes } from '@ultimabase/http';
+/** The upload route, which the plugin mounts without the body limit. */
+export declare const uploads: () => Routes;
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAW9C,wEAAwE;AACxE,eAAO,MAAM,OAAO,QAAO,MA2BxB,CAAA"}

package/dist/routes.js

@@ -0,0 +1,32 @@
+import { routes } from '@ultimabase/http';
+import { PublicError } from 'ultimabase';
+import { upload } from './upload.js';
+/** An upload's own refusals, which the HTTP plugin does not know. */
+const statuses = new Map([
+    ['PAYLOAD_TOO_LARGE', 413],
+    ['UNSUPPORTED_MEDIA_TYPE', 415],
+]);
+/** The upload route, which the plugin mounts without the body limit. */
+export const uploads = () => routes().post('/files', async (c) => {
+    const length = c.req.header('content-length');
+    if (length === undefined) {
+        return c.json({ code: 'LENGTH_REQUIRED', message: 'Content-Length is required.' }, 411);
+    }
+    try {
+        const { id } = await upload(c.req.raw.body ?? new Uint8Array(), Number(length), {
+            for: c.req.query('for') ?? '',
+            name: c.req.query('name') ?? '',
+            type: c.req.header('content-type'),
+            as: c.var.caller,
+        });
+        return c.json({ id }, 201);
+    }
+    catch (error) {
+        if (!(error instanceof PublicError))
+            throw error;
+        const status = statuses.get(error.code);
+        if (status === undefined)
+            throw error;
+        return c.json({ code: error.code, message: error.message }, status);
+    }
+});

package/dist/s3.d.ts

@@ -0,0 +1,17 @@
+import type { FileStorage } from './storage.ts';
+/** What `s3()` takes; the first five are required, read when the application starts. */
+export interface S3Options {
+    readonly bucket: string | undefined;
+    readonly region: string | undefined;
+    /** `https://fra1.digitaloceanspaces.com`. */
+    readonly endpoint: string | undefined;
+    readonly accessKeyId: string | undefined;
+    readonly secretAccessKey: string | undefined;
+    /** Sends `x-amz-acl: public-read` with a public file, which Spaces needs. */
+    readonly publicAcl?: boolean;
+    /** The base of a public file's URL, a CDN; the storage's own otherwise. */
+    readonly publicUrl?: string;
+}
+/** An S3-compatible storage; its options are checked when the application starts. */
+export declare function s3(options: S3Options): FileStorage;
+//# sourceMappingURL=s3.d.ts.map

package/dist/s3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3.d.ts","sourceRoot":"","sources":["../src/s3.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/C,wFAAwF;AACxF,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5C,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC3B;AA+DD,qFAAqF;AACrF,wBAAgB,EAAE,CAAC,OAAO,EAAE,SAAS,GAAG,WAAW,CAyDlD"}

package/dist/s3.js

@@ -0,0 +1,99 @@
+import { presign } from './sigv4.js';
+import { isPublic } from './storage.js';
+const required = [
+    'bucket',
+    'region',
+    'endpoint',
+    'accessKeyId',
+    'secretAccessKey',
+];
+const trimmed = (url) => url.replace(/\/+$/, '');
+/** The options checked: a missing one stops startup, naming it. */
+function configOf(options) {
+    const missing = required.filter((key) => !options[key]);
+    if (missing.length > 0) {
+        throw new Error(`s3() needs ${missing.join(', ')}: undefined or empty.`);
+    }
+    const { bucket = '', region = '', endpoint = '' } = options;
+    const { accessKeyId = '', secretAccessKey = '' } = options;
+    const base = `${trimmed(endpoint)}/${encodeURIComponent(bucket)}`;
+    return { bucket, region, accessKeyId, secretAccessKey, base };
+}
+/** Sent unchanged when the storage answers otherwise. */
+async function answered(response, what, expected = [200]) {
+    if (expected.includes(response.status))
+        return response;
+    const text = await response.text();
+    throw new Error(`s3: ${what} failed with ${response.status}: ${text}`);
+}
+const entities = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+};
+const decoded = (text) => text.replaceAll(/&(amp|lt|gt|quot|apos);/g, (entity, name) => entities[name] ?? entity);
+/** The keys of one `ListObjectsV2` page, and the token of the next. */
+function pageOf(xml) {
+    const keys = [...xml.matchAll(/<Key>([^<]*)<\/Key>/g)].map(([, key = '']) => decoded(key));
+    const truncated = xml.includes('<IsTruncated>true</IsTruncated>');
+    const token = /<NextContinuationToken>([^<]*)</.exec(xml)?.[1];
+    return { keys, next: truncated && token ? decoded(token) : undefined };
+}
+/** An S3-compatible storage; its options are checked when the application starts. */
+export function s3(options) {
+    let config;
+    const configured = () => (config ??= configOf(options));
+    const objectUrl = (key) => new URL(`${configured().base}/${key}`);
+    const signed = (method, url, expires, headers = {}) => presign(configured(), { method, url, expires, headers });
+    return {
+        start: () => {
+            configured();
+        },
+        put: async (key, body, { type, size, attachment }) => {
+            const headers = { 'content-type': type };
+            if (attachment)
+                headers['content-disposition'] = 'attachment';
+            if (isPublic(key) && options.publicAcl === true) {
+                headers['x-amz-acl'] = 'public-read';
+            }
+            const url = signed('PUT', objectUrl(key), 900, headers);
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: { ...headers, 'content-length': String(size) },
+                body,
+                duplex: 'half',
+            });
+            await answered(response, `PUT ${key}`);
+        },
+        delete: async (key) => {
+            const url = signed('DELETE', objectUrl(key), 900);
+            const response = await fetch(url, { method: 'DELETE' });
+            await answered(response, `DELETE ${key}`, [200, 204, 404]);
+        },
+        keys: async () => {
+            const keys = [];
+            let next;
+            do {
+                const list = new URL(configured().base);
+                list.searchParams.set('list-type', '2');
+                if (next !== undefined)
+                    list.searchParams.set('continuation-token', next);
+                const response = await fetch(signed('GET', list, 900));
+                const page = pageOf(await (await answered(response, 'list')).text());
+                keys.push(...page.keys);
+                next = page.next;
+            } while (next !== undefined);
+            return keys;
+        },
+        url: (key) => {
+            if (!isPublic(key))
+                return signed('GET', objectUrl(key), 3600);
+            const { publicUrl } = options;
+            return publicUrl === undefined
+                ? objectUrl(key).href
+                : `${trimmed(publicUrl)}/${key}`;
+        },
+    };
+}

package/dist/shape.d.ts

@@ -0,0 +1,17 @@
+import type { StandardSchema } from './standard.ts';
+import type { FileOptions } from './field.ts';
+type Node = {
+    readonly [key: string]: unknown;
+};
+type Exported = {
+    readonly jsonSchema: {
+        readonly input: () => Node;
+        readonly output: () => Node;
+    };
+};
+/** What a field with `options` gives clients, as a Standard Schema. */
+export declare const shapeOf: (options: FileOptions) => StandardSchema & {
+    readonly '~standard': Exported;
+};
+export {};
+//# sourceMappingURL=shape.d.ts.map

package/dist/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../src/shape.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,KAAK,IAAI,GAAG;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAA;AAC/C,KAAK,QAAQ,GAAG;IACf,QAAQ,CAAC,UAAU,EAAE;QACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;QAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAA;KAC3B,CAAA;CACD,CAAA;AAyDD,uEAAuE;AACvE,eAAO,MAAM,OAAO,YACV,WAAW,KAClB,cAAc,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAA;CAUlD,CAAA"}

package/dist/shape.js

@@ -0,0 +1,59 @@
+const isNode = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const string = { type: 'string' };
+const size = { type: 'integer', minimum: 0 };
+const nullable = (node) => Object.keys(node).length === 0 ? node : { anyOf: [node, { type: 'null' }] };
+const closed = (properties) => ({
+    type: 'object',
+    properties,
+    required: Object.keys(properties),
+    additionalProperties: false,
+});
+/** An inline value's JSON Schema, from its schema's; any JSON without one. */
+function inlineOf(inline) {
+    if (!isNode(inline) || !isNode(inline['schema']))
+        return {};
+    const standard = inline['schema']['~standard'];
+    const exporter = isNode(standard) ? standard['jsonSchema'] : undefined;
+    const output = isNode(exporter) ? exporter['output'] : undefined;
+    if (typeof output !== 'function')
+        return {};
+    const node = Reflect.apply(output, exporter, [
+        { target: 'draft-2020-12' },
+    ]);
+    if (!isNode(node))
+        return {};
+    const { $schema: _, ...rest } = node;
+    return rest;
+}
+function fileNode(options) {
+    const inline = Object.entries(options.inline ?? {}).map(([key, given]) => [key, nullable(inlineOf(given))]);
+    const variant = closed({ type: string, size, url: string });
+    const variants = Object.keys(options.variants ?? {}).map((key) => [key, nullable(variant)]);
+    return closed({
+        id: string,
+        name: string,
+        type: string,
+        size,
+        url: string,
+        inline: closed(Object.fromEntries(inline)),
+        variants: closed(Object.fromEntries(variants)),
+    });
+}
+function nodeOf(options) {
+    const node = fileNode(options);
+    if (options.list === true)
+        return { type: 'array', items: node };
+    return options.optional === true ? nullable(node) : node;
+}
+/** What a field with `options` gives clients, as a Standard Schema. */
+export const shapeOf = (options) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'ultimabase-files',
+        validate: (value) => ({ value }),
+        jsonSchema: {
+            input: () => nodeOf(options),
+            output: () => nodeOf(options),
+        },
+    },
+});

package/dist/sigv4.d.ts

@@ -0,0 +1,18 @@
+export interface Signer {
+    readonly region: string;
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+}
+export interface Presigned {
+    readonly method: string;
+    readonly url: URL;
+    /** The headers the request sends and signs, `host` added. */
+    readonly headers: {
+        readonly [name: string]: string;
+    };
+    /** In seconds. */
+    readonly expires: number;
+}
+/** The URL that runs the request until it expires, signed now. */
+export declare function presign(signer: Signer, request: Presigned): string;
+//# sourceMappingURL=sigv4.d.ts.map

package/dist/sigv4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sigv4.d.ts","sourceRoot":"","sources":["../src/sigv4.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,MAAM;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAChC;AAED,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IACrD,kBAAkB;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB;AAmBD,kEAAkE;AAClE,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM,CA0ClE"}

package/dist/sigv4.js

@@ -0,0 +1,49 @@
+// AWS Signature Version 4, query presigning (D-152): on `node:crypto`, which
+// is synchronous, so a read signs its URLs while it decodes. The payload is
+// unsigned, as presigned URLs are.
+import { createHash, createHmac } from 'node:crypto';
+/** RFC 3986, as SigV4 encodes: everything but `A-Za-z0-9-_.~`. */
+const encoded = (value) => encodeURIComponent(value).replaceAll(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+const hmac = (key, value) => createHmac('sha256', key).update(value).digest();
+/** `20130524T000000Z`. */
+const stampOf = (now) => now
+    .toISOString()
+    .replaceAll(/[-:]/g, '')
+    .replace(/\.\d{3}/, '');
+/** The URL that runs the request until it expires, signed now. */
+export function presign(signer, request) {
+    const { method, url, expires } = request;
+    const stamp = stampOf(new Date());
+    const day = stamp.slice(0, 8);
+    const scope = `${day}/${signer.region}/s3/aws4_request`;
+    const headers = new Map(Object.entries({ ...request.headers, host: url.host }).map(([name, value]) => [name.toLowerCase(), value.trim()]));
+    const names = [...headers.keys()].toSorted();
+    const signed = names.join(';');
+    const query = new URLSearchParams(url.search);
+    query.set('X-Amz-Algorithm', 'AWS4-HMAC-SHA256');
+    query.set('X-Amz-Credential', `${signer.accessKeyId}/${scope}`);
+    query.set('X-Amz-Date', stamp);
+    query.set('X-Amz-Expires', String(expires));
+    query.set('X-Amz-SignedHeaders', signed);
+    const canonicalQuery = [...query]
+        .map(([key, value]) => [encoded(key), encoded(value)])
+        .toSorted(([a = ''], [b = '']) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([key, value]) => `${key}=${value}`)
+        .join('&');
+    const path = url.pathname
+        .split('/')
+        .map((part) => encoded(decodeURIComponent(part)));
+    const canonical = [
+        method,
+        path.join('/'),
+        canonicalQuery,
+        names.map((name) => `${name}:${headers.get(name)}\n`).join(''),
+        signed,
+        'UNSIGNED-PAYLOAD',
+    ].join('\n');
+    const digest = createHash('sha256').update(canonical).digest('hex');
+    const toSign = ['AWS4-HMAC-SHA256', stamp, scope, digest].join('\n');
+    const key = ['s3', 'aws4_request'].reduce(hmac, hmac(hmac(`AWS4${signer.secretAccessKey}`, day), signer.region));
+    const signature = createHmac('sha256', key).update(toSign).digest('hex');
+    return `${url.origin}${path.join('/')}?${canonicalQuery}&X-Amz-Signature=${signature}`;
+}

package/dist/standard.d.ts

@@ -0,0 +1,21 @@
+export interface StandardSchema<I = unknown, O = I> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => SchemaResult<O> | Promise<SchemaResult<O>>;
+        readonly types?: {
+            readonly input: I;
+            readonly output: O;
+        } | undefined;
+    };
+}
+type SchemaResult<O> = {
+    readonly value: O;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly {
+        readonly message: string;
+    }[];
+};
+export {};
+//# sourceMappingURL=standard.d.ts.map

package/dist/standard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard.d.ts","sourceRoot":"","sources":["../src/standard.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC;IACjD,QAAQ,CAAC,WAAW,EAAE;QACrB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;QACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,QAAQ,EAAE,CAClB,KAAK,EAAE,OAAO,KACV,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;QAC/C,QAAQ,CAAC,KAAK,CAAC,EAAE;YAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;SAAE,GAAG,SAAS,CAAA;KACtE,CAAA;CACD;AACD,KAAK,YAAY,CAAC,CAAC,IAChB;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAA"}

package/dist/standard.js

@@ -0,0 +1 @@
+export {};

package/dist/storage.d.ts

@@ -0,0 +1,30 @@
+/** A file's bytes: streamed from a request, or held in memory. */
+export type FileBody = ReadableStream<Uint8Array> | Uint8Array;
+/** How an object is stored and served. */
+export interface PutOptions {
+    readonly type: string;
+    /** The body's length in bytes, which the storage checks. */
+    readonly size: number;
+    /** Served as a download, so a browser never runs it: SVG, undetected types. */
+    readonly attachment: boolean;
+}
+/** A storage adapter: `s3()` or `memoryFiles()`. */
+export interface FileStorage {
+    /** Checks its options when the application starts. */
+    start(): void;
+    put(key: string, body: FileBody, options: PutOptions): Promise<void>;
+    /** Deletes an object; a missing one is not an error. */
+    delete(key: string): Promise<void>;
+    /** Every key it stores. */
+    keys(): Promise<readonly string[]>;
+    /** A public object's stable URL, a private one's presigned for one hour. */
+    url(key: string): string;
+}
+/** Whether a key is served to everyone. */
+export declare const isPublic: (key: string) => boolean;
+/**
+ * Each promise ended, then the first failure thrown: a put still running
+ * would store an object after its cleanup.
+ */
+export declare function settled<T>(promises: readonly Promise<T>[]): Promise<T[]>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAIA,kEAAkE;AAClE,MAAM,MAAM,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,GAAG,UAAU,CAAA;AAE9D,0CAA0C;AAC1C,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC5B;AAED,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC3B,sDAAsD;IACtD,KAAK,IAAI,IAAI,CAAA;IACb,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpE,wDAAwD;IACxD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClC,2BAA2B;IAC3B,IAAI,IAAI,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAA;IAClC,4EAA4E;IAC5E,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CACxB;AAED,2CAA2C;AAC3C,eAAO,MAAM,QAAQ,QAAS,MAAM,KAAG,OAAoC,CAAA;AAE3E;;;GAGG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAC9B,QAAQ,EAAE,SAAS,OAAO,CAAC,CAAC,CAAC,EAAE,GAC7B,OAAO,CAAC,CAAC,EAAE,CAAC,CAOd"}

package/dist/storage.js

@@ -0,0 +1,16 @@
+// What `filesPlugin` stores files in (D-152): an S3-compatible storage, or
+// memory for tests. A key starts with `public/` or `private/`, which says
+// how the object is served.
+/** Whether a key is served to everyone. */
+export const isPublic = (key) => key.startsWith('public/');
+/**
+ * Each promise ended, then the first failure thrown: a put still running
+ * would store an object after its cleanup.
+ */
+export async function settled(promises) {
+    const results = await Promise.allSettled(promises);
+    const failed = results.find((result) => result.status === 'rejected');
+    if (failed !== undefined)
+        throw failed.reason;
+    return results.flatMap((result) => result.status === 'fulfilled' ? [result.value] : []);
+}

package/dist/upload.d.ts

@@ -0,0 +1,19 @@
+import type { Identity } from 'ultimabase';
+import type { FileBody } from './storage.ts';
+/** What an upload says of its file. */
+export interface UploadOptions {
+    /** The field the file is for: `Post.cover`. */
+    readonly for: string;
+    readonly name: string;
+    /** The declared `Content-Type`, read only when the bytes say none. */
+    readonly type?: string | undefined;
+    readonly as?: Identity | undefined;
+}
+/**
+ * Stores a file for `options.for`, as `POST /files` does, and gives its id,
+ * which a write of that field takes. `size` is the body's length in bytes.
+ */
+export declare function upload(body: FileBody, size: number, options: UploadOptions): Promise<{
+    readonly id: string;
+}>;
+//# sourceMappingURL=upload.d.ts.map

package/dist/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../src/upload.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,YAAY,CAAA;AAMrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAI5C,uCAAuC;AACvC,MAAM,WAAW,aAAa;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;CAClC;AAmKD;;;GAGG;AACH,wBAAsB,MAAM,CAC3B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAuFlC"}