@brydio/manifest 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brydio Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@brydio/manifest",
+  "version": "0.1.0-alpha.0",
+  "description": "The shape of a Brydio app's manifest, its collections' schemas, and the checks that say what is wrong with one.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Brydio Inc.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nakel-ola/brydio-sdk",
+    "directory": "packages/manifest"
+  },
+  "gitHead": "da4f607b1e4bc8e5221b7556d03c67de30503f5d",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "zod": "4.6.2"
+  }
+}

package/src/base.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+/**
+ * The manifest every Brydio app has had since before apps drew screens.
+ *
+ * A copy of Brydio's `apps/api/src/extensions/apps/manifest.schema.ts` (E5's
+ * canonical `.brydio/app.json`) and the three numbers and formats it takes
+ * from `manifest-codes.ts`. Copied rather than imported because the SDK
+ * imports nothing from Brydio's tree (A5-F01-S01); `test/manifest.test.ts`
+ * holds the two side by side whenever a Brydio checkout is beside this one.
+ */
+export declare const MANIFEST_LIMITS: {
+    readonly nameChars: 64;
+    readonly versionChars: 64;
+    readonly displayNameChars: 80;
+    readonly summaryChars: 240;
+    readonly descriptionChars: 4000;
+    readonly licenseChars: 64;
+    readonly keywords: 20;
+    readonly defaultPrompts: 3;
+};
+/** Kebab-case: "acme-projects", not "Acme Projects". */
+export declare const APP_NAME_FORMAT: RegExp;
+/** Semver, the permissive reading: `1.0.0-beta.2` is a version. */
+export declare const SEMVER_FORMAT: RegExp;
+export declare const authorSchema: z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const linksSchema: z.ZodObject<{
+    privacy: z.ZodOptional<z.ZodString>;
+    terms: z.ZodOptional<z.ZodString>;
+    support: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const requiresSchema: z.ZodObject<{
+    servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    integrations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    builtin: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const baseManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    homepage: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    links: z.ZodOptional<z.ZodObject<{
+        privacy: z.ZodOptional<z.ZodString>;
+        terms: z.ZodOptional<z.ZodString>;
+        support: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    icon: z.ZodOptional<z.ZodString>;
+    brandColor: z.ZodOptional<z.ZodString>;
+    brandColorDark: z.ZodOptional<z.ZodString>;
+    defaultPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skills: z.ZodOptional<z.ZodString>;
+    servers: z.ZodOptional<z.ZodString>;
+    integrations: z.ZodOptional<z.ZodString>;
+    requires: z.ZodOptional<z.ZodObject<{
+        servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        integrations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        builtin: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;

package/src/base.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+/**
+ * The manifest every Brydio app has had since before apps drew screens.
+ *
+ * A copy of Brydio's `apps/api/src/extensions/apps/manifest.schema.ts` (E5's
+ * canonical `.brydio/app.json`) and the three numbers and formats it takes
+ * from `manifest-codes.ts`. Copied rather than imported because the SDK
+ * imports nothing from Brydio's tree (A5-F01-S01); `test/manifest.test.ts`
+ * holds the two side by side whenever a Brydio checkout is beside this one.
+ */
+export const MANIFEST_LIMITS = {
+    nameChars: 64,
+    versionChars: 64,
+    displayNameChars: 80,
+    summaryChars: 240,
+    descriptionChars: 4_000,
+    licenseChars: 64,
+    keywords: 20,
+    defaultPrompts: 3,
+};
+/** Kebab-case: "acme-projects", not "Acme Projects". */
+export const APP_NAME_FORMAT = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/** Semver, the permissive reading: `1.0.0-beta.2` is a version. */
+export const SEMVER_FORMAT = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export const authorSchema = z.object({
+    name: z.string().min(1),
+    email: z.string().optional(),
+    url: z.string().optional(),
+});
+export const linksSchema = z.object({
+    privacy: z.string().optional(),
+    terms: z.string().optional(),
+    support: z.string().optional(),
+});
+export const requiresSchema = z.object({
+    servers: z.array(z.string()).default([]),
+    integrations: z.array(z.string()).default([]),
+    builtin: z.array(z.string()).default([]),
+});
+export const baseManifestSchema = z.object({
+    name: z.string().min(1).max(MANIFEST_LIMITS.nameChars).regex(APP_NAME_FORMAT),
+    version: z.string().max(MANIFEST_LIMITS.versionChars).regex(SEMVER_FORMAT),
+    displayName: z.string().max(MANIFEST_LIMITS.displayNameChars).optional(),
+    summary: z.string().max(MANIFEST_LIMITS.summaryChars).optional(),
+    description: z.string().max(MANIFEST_LIMITS.descriptionChars).optional(),
+    author: authorSchema.optional(),
+    homepage: z.string().optional(),
+    repository: z.string().optional(),
+    license: z.string().max(MANIFEST_LIMITS.licenseChars).optional(),
+    keywords: z.array(z.string()).max(MANIFEST_LIMITS.keywords).optional(),
+    links: linksSchema.optional(),
+    icon: z.string().optional(),
+    brandColor: z.string().optional(),
+    brandColorDark: z.string().optional(),
+    defaultPrompts: z.array(z.string()).max(MANIFEST_LIMITS.defaultPrompts).optional(),
+    skills: z.string().optional(),
+    servers: z.string().optional(),
+    integrations: z.string().optional(),
+    requires: requiresSchema.optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});

package/src/bundle.d.ts

@@ -0,0 +1,52 @@
+/**
+ * What a bundle may hold, and the fingerprint its code is served under
+ * (contracts §11, A7-F02).
+ *
+ * The rules and the recipe are Brydio's, from
+ * `apps/api/src/apps/bundles/bundle-files.ts`, which refuses a bundle at the
+ * store. The SDK applies them first so a refusal is something the builder sees
+ * on their own machine, with the same numbers and the same words, and so
+ * `brydio build` can print the fingerprint the server will serve the code
+ * under before anything is uploaded.
+ */
+/** 1 MB per version, every file counted, the manifest included. */
+export declare const BUNDLE_MAX_BYTES: number;
+/** The manifest, at the root of every published bundle. Never stored, never hashed. */
+export declare const BUNDLE_MANIFEST = "app.json";
+export declare const BUNDLE_PATH_MAX_CHARS = 200;
+/** The files of one bundle, by path inside it. */
+export type BundleFiles = ReadonlyMap<string, Uint8Array>;
+/**
+ * Whether a path can name a file inside a bundle: relative, forward slashes,
+ * no empty, `.` or `..` segment, no hidden segment, plain printable ASCII.
+ */
+export declare function isBundlePath(path: string): boolean;
+/** Whether a path is a script a bundle can hold. */
+export declare const isScriptPath: (path: string) => boolean;
+/** The files the store keeps and the fingerprint covers: every one but the root manifest. */
+export declare function codeOf(files: BundleFiles): BundleFiles;
+/**
+ * The fingerprint: sha256, lowercase hex, over the sorted list of the code
+ * files, each written as its path, one NUL byte, the sha256 hex of its bytes
+ * and one newline.
+ *
+ * Over the files rather than an archive, because two zips of the same files
+ * differ by their timestamps. Without `app.json`, because the manifest carries
+ * the version number, and the same code under two numbers has to be one
+ * bundle. Sorted by JavaScript's default string order, as the server sorts.
+ */
+export declare function bundleHash(files: BundleFiles): string;
+export type BundleProblemCode = 'bundle_too_large' | 'bundle_file_not_code' | 'bundle_path_invalid' | 'bundle_manifest_missing' | 'bundle_empty';
+export interface BundleProblem {
+    code: BundleProblemCode;
+    message: string;
+    file?: string;
+}
+/**
+ * What the store would refuse about these files, or null. The server's order
+ * and words: every path first, then the manifest, then the code, then the size.
+ */
+export declare function bundleProblem(files: BundleFiles): BundleProblem | null;
+/** Every file's bytes, the manifest included: what the cap is measured on. */
+export declare const bundleBytes: (files: BundleFiles) => number;
+export declare function sizeOf(bytes: number): string;

package/src/bundle.js

@@ -0,0 +1,95 @@
+import { createHash } from 'node:crypto';
+/**
+ * What a bundle may hold, and the fingerprint its code is served under
+ * (contracts §11, A7-F02).
+ *
+ * The rules and the recipe are Brydio's, from
+ * `apps/api/src/apps/bundles/bundle-files.ts`, which refuses a bundle at the
+ * store. The SDK applies them first so a refusal is something the builder sees
+ * on their own machine, with the same numbers and the same words, and so
+ * `brydio build` can print the fingerprint the server will serve the code
+ * under before anything is uploaded.
+ */
+/** 1 MB per version, every file counted, the manifest included. */
+export const BUNDLE_MAX_BYTES = 1024 * 1024;
+/** The manifest, at the root of every published bundle. Never stored, never hashed. */
+export const BUNDLE_MANIFEST = 'app.json';
+export const BUNDLE_PATH_MAX_CHARS = 200;
+const SCRIPT = /\.m?js$/;
+/**
+ * Whether a path can name a file inside a bundle: relative, forward slashes,
+ * no empty, `.` or `..` segment, no hidden segment, plain printable ASCII.
+ */
+export function isBundlePath(path) {
+    if (path.length === 0 || path.length > BUNDLE_PATH_MAX_CHARS)
+        return false;
+    if (!/^[A-Za-z0-9._\-/]+$/.test(path))
+        return false;
+    return path.split('/').every(segment => segment.length > 0 && !segment.startsWith('.'));
+}
+/** Whether a path is a script a bundle can hold. */
+export const isScriptPath = (path) => isBundlePath(path) && SCRIPT.test(path);
+/** The files the store keeps and the fingerprint covers: every one but the root manifest. */
+export function codeOf(files) {
+    return new Map([...files].filter(([path]) => path !== BUNDLE_MANIFEST));
+}
+const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+/**
+ * The fingerprint: sha256, lowercase hex, over the sorted list of the code
+ * files, each written as its path, one NUL byte, the sha256 hex of its bytes
+ * and one newline.
+ *
+ * Over the files rather than an archive, because two zips of the same files
+ * differ by their timestamps. Without `app.json`, because the manifest carries
+ * the version number, and the same code under two numbers has to be one
+ * bundle. Sorted by JavaScript's default string order, as the server sorts.
+ */
+export function bundleHash(files) {
+    const code = codeOf(files);
+    const lines = [...code.keys()].sort().map(path => `${path}\0${sha256(code.get(path))}\n`);
+    return sha256(lines.join(''));
+}
+/**
+ * What the store would refuse about these files, or null. The server's order
+ * and words: every path first, then the manifest, then the code, then the size.
+ */
+export function bundleProblem(files) {
+    for (const path of files.keys()) {
+        if (!isBundlePath(path)) {
+            return { code: 'bundle_path_invalid', message: `"${JSON.stringify(path).slice(1, -1)}" is not a path a bundle can hold.`, file: path };
+        }
+        if (path !== BUNDLE_MANIFEST && !SCRIPT.test(path)) {
+            return {
+                code: 'bundle_file_not_code',
+                message: `"${path}" is not a script. A bundle holds only .js files and ${BUNDLE_MANIFEST}.`,
+                file: path,
+            };
+        }
+    }
+    if (!files.has(BUNDLE_MANIFEST)) {
+        return { code: 'bundle_manifest_missing', message: `That bundle has no ${BUNDLE_MANIFEST} at its root.` };
+    }
+    if (codeOf(files).size === 0) {
+        return { code: 'bundle_empty', message: 'That bundle has no screens in it, only a manifest.' };
+    }
+    const total = bundleBytes(files);
+    if (total > BUNDLE_MAX_BYTES) {
+        const [largest] = [...files].sort(([, a], [, b]) => b.length - a.length);
+        return {
+            code: 'bundle_too_large',
+            message: `That bundle is ${sizeOf(total)}, over the ${sizeOf(BUNDLE_MAX_BYTES)} cap. ` +
+                `The largest file is "${largest[0]}" at ${sizeOf(largest[1].length)}.`,
+            file: largest[0],
+        };
+    }
+    return null;
+}
+/** Every file's bytes, the manifest included: what the cap is measured on. */
+export const bundleBytes = (files) => [...files.values()].reduce((sum, bytes) => sum + bytes.length, 0);
+export function sizeOf(bytes) {
+    if (bytes < 1024)
+        return `${bytes} bytes`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}

package/src/define.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A manifest written in TypeScript, checked as it is written (A5-F01-S03).
+ *
+ * `.brydio/app.json` is what Brydio reads, and `validate` checks it. An app
+ * that also keeps its manifest in code (to share its collections' schemas
+ * with its screens, say) gets one more check at type level: a placement that
+ * names a screen the manifest doesn't declare doesn't compile.
+ *
+ * ```ts
+ * export const manifest = defineManifest({
+ *   name: 'issues',
+ *   version: '0.1.0',
+ *   screens: { board: { entry: 'screens/board.js' } },
+ *   placements: [{ kind: 'project-tab', screen: 'bord' }],   // error: "bord" is not a screen
+ * });
+ * ```
+ */
+/** The parts of a manifest this check reads. Everything else passes through as written. */
+export interface ManifestShape {
+    name: string;
+    version: string;
+    screens?: Readonly<Record<string, {
+        readonly entry: string;
+    }>>;
+    placements?: readonly {
+        readonly kind: string;
+        readonly screen: string;
+        readonly label?: string;
+        readonly icon?: string;
+    }[];
+    [field: string]: unknown;
+}
+/** The screen names a manifest declares. */
+export type ScreenNameOf<M> = M extends {
+    readonly screens: infer S;
+} ? Extract<keyof S, string> : never;
+/** A manifest whose every placement names one of its own screens. */
+export type WithDeclaredScreens<M> = M extends {
+    readonly placements: readonly unknown[];
+} ? Omit<M, 'placements'> & {
+    readonly placements: readonly {
+        readonly kind: string;
+        readonly screen: ScreenNameOf<M>;
+        readonly label?: string;
+        readonly icon?: string;
+    }[];
+} : M;
+/** Returns the manifest as written, with its literal types, once its placements check. */
+export declare function defineManifest<const M extends ManifestShape>(manifest: M & WithDeclaredScreens<M>): M;

package/src/define.js

@@ -0,0 +1,21 @@
+/**
+ * A manifest written in TypeScript, checked as it is written (A5-F01-S03).
+ *
+ * `.brydio/app.json` is what Brydio reads, and `validate` checks it. An app
+ * that also keeps its manifest in code (to share its collections' schemas
+ * with its screens, say) gets one more check at type level: a placement that
+ * names a screen the manifest doesn't declare doesn't compile.
+ *
+ * ```ts
+ * export const manifest = defineManifest({
+ *   name: 'issues',
+ *   version: '0.1.0',
+ *   screens: { board: { entry: 'screens/board.js' } },
+ *   placements: [{ kind: 'project-tab', screen: 'bord' }],   // error: "bord" is not a screen
+ * });
+ * ```
+ */
+/** Returns the manifest as written, with its literal types, once its placements check. */
+export function defineManifest(manifest) {
+    return manifest;
+}

package/src/document-limits.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The bounds on one app's records, as Brydio's store holds them (A3-F02-S04).
+ *
+ * A copy of `DOCUMENT_LIMITS` in Brydio's `apps/api/src/apps/data/document-query.ts`,
+ * held to it by `limits-doc.test.ts`, and listed for app builders in
+ * `docs/manifest.md`. `FIELD_LIMITS` holds the bounds on a schema and its values.
+ */
+export declare const DOCUMENT_LIMITS: {
+    /** Records a list or search returns when it doesn't say how many. */
+    readonly pageDefault: 50;
+    /** The most records one list or search page may return. */
+    readonly pageMax: 200;
+    /** One record's stored body, in bytes: 256 KB, so a `text` field's 100,000 characters fit. */
+    readonly bodyBytes: number;
+    /** A page stops adding records once it passes this many bytes, and hands back a cursor. */
+    readonly pageBytes: number;
+    /** Live records one instance's collection may hold. */
+    readonly recordsPerCollection: 100000;
+    /** Changes one `batch_<plural>` call may make. */
+    readonly batchChanges: 50;
+};

package/src/document-limits.js

@@ -0,0 +1,21 @@
+/**
+ * The bounds on one app's records, as Brydio's store holds them (A3-F02-S04).
+ *
+ * A copy of `DOCUMENT_LIMITS` in Brydio's `apps/api/src/apps/data/document-query.ts`,
+ * held to it by `limits-doc.test.ts`, and listed for app builders in
+ * `docs/manifest.md`. `FIELD_LIMITS` holds the bounds on a schema and its values.
+ */
+export const DOCUMENT_LIMITS = {
+    /** Records a list or search returns when it doesn't say how many. */
+    pageDefault: 50,
+    /** The most records one list or search page may return. */
+    pageMax: 200,
+    /** One record's stored body, in bytes: 256 KB, so a `text` field's 100,000 characters fit. */
+    bodyBytes: 256 * 1024,
+    /** A page stops adding records once it passes this many bytes, and hands back a cursor. */
+    pageBytes: 2 * 1024 * 1024,
+    /** Live records one instance's collection may hold. */
+    recordsPerCollection: 100_000,
+    /** Changes one `batch_<plural>` call may make. */
+    batchChanges: 50,
+};

package/src/field-types.d.ts

@@ -0,0 +1,157 @@
+import { type ZodType } from 'zod';
+/**
+ * The field types an app's collection may declare (contracts §5, A3-F01).
+ *
+ * Deliberately few. A tracker, a library and a folder can all be written in
+ * these, and every one of them is something Brydio knows how to store, how to
+ * validate, how to describe to the assistant and how to draw in a form. A
+ * type an app could invent would be a type none of those four knew about.
+ *
+ * The manifest writes a type as a string (`"member?"`) or, for a choice, as
+ * the list of allowed values. `parseFieldType` turns either into one shape,
+ * and everything downstream — the store, the generated tools, the screen's
+ * form — reads that shape, never the manifest's spelling.
+ */
+export type FieldKind = 'string' | 'text' | 'enum' | 'member' | 'project' | 'date' | 'number' | 'boolean' | 'string[]' | 'token';
+export interface FieldType {
+    kind: FieldKind;
+    /** Written with a trailing `?`: may be left out on create. */
+    optional: boolean;
+    /** The allowed values, for an enumeration and for a token. */
+    values?: readonly string[];
+    /** What a create that leaves the field out stores: a choice's value, or a boolean. */
+    default?: string | boolean;
+    /**
+     * How a choice's values read to a person: `{ todo: "To do" }`. Shown on the
+     * approval card and in the tools' descriptions; the stored value never
+     * changes, and a value with no label reads as itself.
+     */
+    labels?: Readonly<Record<string, string>>;
+}
+/**
+ * The bounds a schema and a record are held to (A3-F01-S03).
+ *
+ * `stringChars` is 1,000 (E1, 16 Sep: the feature file wins over contracts'
+ * old 512), the same as `bry-input`'s `INPUT_MAX`, so nothing a person can
+ * type into a text field is refused by the store.
+ */
+export declare const FIELD_LIMITS: {
+    /** Collections one app may keep. */
+    readonly collections: 20;
+    /** Fields one collection may have. */
+    readonly fields: 40;
+    /** Values one choice may allow. */
+    readonly enumValues: 50;
+    /** Characters in one of a choice's values. */
+    readonly enumValueChars: 64;
+    /** Characters in a `string` value, the same as `bry-input` lets a person type. */
+    readonly stringChars: 1000;
+    /** Characters in a `text` value. */
+    readonly textChars: 100000;
+    /** Entries in a `string[]` value. */
+    readonly listEntries: 100;
+    /** Characters in a collection, label, field or screen name. */
+    readonly nameChars: 40;
+};
+/**
+ * The colours a `token` field may hold, by design-token name.
+ *
+ * The status roles `DESIGN_SYSTEM.md` already gives a solid, a text, a tint
+ * and an edge, plus the brand and a neutral. A label picks one by name and
+ * the host draws it in the current theme, so an app never holds a colour
+ * value it could get wrong in dark mode (ADR-A13). `@brydio/manifest` carries
+ * the same list.
+ */
+export declare const COLOUR_TOKENS: readonly ["neutral", "brand", "success", "warn", "danger"];
+/**
+ * Names Brydio keeps on every record, or that the generated tools already
+ * use for their own arguments. A field called `version` would be ambiguous in
+ * `update_issue`, and one called `instance` would shadow ADR-A09's argument.
+ */
+export declare const RESERVED_FIELDS: ReadonlySet<string>;
+/** A field, collection or label name: an identifier the tools can use as-is. */
+export declare const FIELD_NAME: RegExp;
+export declare const COLLECTION_NAME: RegExp;
+/** A field type the manifest wrote that Brydio does not have, or a bad list. */
+export declare class FieldTypeInvalid extends Error {
+    readonly code: 'data_field_type_unknown' | 'data_enum_empty' | 'data_enum_too_many' | 'data_enum_value_invalid' | 'data_enum_duplicate' | 'data_default_not_allowed' | 'data_default_on_required' | 'data_default_invalid' | 'data_labels_not_allowed' | 'data_label_invalid' | 'data_label_unknown_value' | 'data_field_key_unknown';
+    constructor(code: 'data_field_type_unknown' | 'data_enum_empty' | 'data_enum_too_many' | 'data_enum_value_invalid' | 'data_enum_duplicate' | 'data_default_not_allowed' | 'data_default_on_required' | 'data_default_invalid' | 'data_labels_not_allowed' | 'data_label_invalid' | 'data_label_unknown_value' | 'data_field_key_unknown', message: string);
+}
+/**
+ * One field's manifest spelling, as a type.
+ *
+ * Throws `FieldTypeInvalid` with a code rather than returning null, because
+ * "unknown type" and "a choice with 51 values" are different mistakes and the
+ * import report has to say which.
+ */
+export declare function parseFieldType(raw: unknown): FieldType;
+/** How long a choice value's label may be. */
+export declare const LABEL_CHARS = 60;
+/** How a choice's value reads to a person: its label, or the value itself. */
+export declare const labelOfValue: (type: FieldType, value: string) => string;
+/** True for a type whose value lands in the plain `fields` column. */
+export declare const isStructured: (type: FieldType) => boolean;
+/** True for a type a list can be ordered by: structured, and one value. */
+export declare const isSortable: (type: FieldType) => boolean;
+export declare const isSearchable: (type: FieldType) => boolean;
+/**
+ * The names of a schema's structured fields: the ones kept in plain beside the
+ * encrypted body, and so the ones a list may filter on.
+ *
+ * One function, imported by the store and by the tools, so what is written
+ * plainly and what may be filtered cannot drift apart (A3-F01's note). Accepts
+ * the manifest's spelling or parsed types.
+ */
+export declare function structuredFields(schema: Record<string, unknown>): string[];
+/**
+ * What one value of this type may be, as zod.
+ *
+ * The same schema checks a record in the store and describes the argument to
+ * the model, so the tool never accepts something the store then refuses.
+ * Always the required form: callers add `.optional()` where they mean it.
+ */
+export declare function valueSchema(type: FieldType): ZodType;
+/**
+ * Why a value is not one of this type, in words the assistant can repeat to
+ * the person, naming the field. Null when it is fine.
+ */
+export declare function valueProblem(field: string, type: FieldType, value: unknown): string | null;
+/** A type in a few words, for a tool's description: every allowed value named. */
+export declare function describeType(type: FieldType): string;
+export declare const quoted: (values: readonly string[]) => string;
+type Optional<T> = T extends `${string}?` ? true : T extends {
+    optional: true;
+} ? true : T extends {
+    type: infer U;
+} ? Optional<U> : false;
+/** The TypeScript type of one field's value, from its manifest spelling. */
+export type FieldValue<T> = T extends {
+    type: infer U;
+} ? FieldValue<U> : T extends readonly (infer V)[] ? V : T extends 'number' | 'number?' ? number : T extends 'boolean' | 'boolean?' ? boolean : T extends 'string[]' | 'string[]?' ? string[] : T extends 'token' | 'token?' ? (typeof COLOUR_TOKENS)[number] : T extends string ? string : never;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** A schema's fields as a type: optional fields may be absent or null. */
+export type FieldsOf<S> = Simplify<{
+    -readonly [K in keyof S as Optional<S[K]> extends true ? never : K]: FieldValue<S[K]>;
+} & {
+    -readonly [K in keyof S as Optional<S[K]> extends true ? K : never]?: FieldValue<S[K]> | null;
+}>;
+/**
+ * A record of a collection, as the generated tools hand it out: its id and
+ * version beside the schema's fields, flat, so what `get` returns is the
+ * shape `update` takes.
+ *
+ * ```ts
+ * const schema = { title: 'string', status: ['todo', 'doing', 'done'] } as const;
+ * type Issue = DocumentOf<typeof schema>;   // { id; version; title: string; status: 'todo' | … }
+ * ```
+ */
+export type DocumentOf<S> = Simplify<{
+    id: string;
+    version: number;
+    createdBy?: string;
+    createdAt?: string;
+    updatedAt?: string;
+} & FieldsOf<S>>;
+export {};