@beechcms/core 0.8.1 → 0.9.1

package/dist/engine/introspection.js

@@ -1,127 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-/** Thrown when live state cannot be read or cannot be trusted. */
-export class IntrospectionError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = 'IntrospectionError';
-    }
-}
-/**
- * SQLite identifiers cannot be bound as parameters, so every table name reaching a PRAGMA is
- * interpolated — and therefore must be proven safe first. Table names in this system are always
- * `content_{slug}` / `rel_{slug}_{alias}` / a structural table, all of which match this pattern.
- */
-const SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
-/** Returns `name` unchanged when it is a safe SQL identifier; throws otherwise. */
-export function assertSafeIdentifier(name) {
-    if (!SAFE_IDENTIFIER.test(name)) {
-        throw new IntrospectionError(`Refusing to introspect '${name}': not a plain SQL identifier. Table names are never user input in BeechCMS.`);
-    }
-    return name;
-}
-/**
- * Physical state of one table. A table SQLite does not know returns `{ exists: false }` with empty
- * lists rather than throwing: "missing" is a legitimate diff outcome, not an error.
- *
- * `PRAGMA table_info` answers an unknown table with zero rows on the SQLite path and raises on some
- * wrangler paths, so both outcomes collapse to the same result.
- */
-export async function introspectTable(executor, table) {
-    const name = assertSafeIdentifier(table);
-    const empty = { name, exists: false, columns: [], foreignKeys: [], indexes: [] };
-    let info;
-    try {
-        info = await executor.all(`PRAGMA table_info(${name})`);
-    }
-    catch {
-        return empty;
-    }
-    if (info.length === 0)
-        return empty;
-    const columns = info.map(row => ({
-        name: row.name,
-        sqlType: String(row.type ?? '').toUpperCase(),
-        notNull: row.notnull === 1,
-        isPk: row.pk > 0,
-        defaultValue: row.dflt_value ?? null,
-    }));
-    let fkRows = [];
-    let indexRows = [];
-    try {
-        fkRows = await executor.all(`PRAGMA foreign_key_list(${name})`);
-        indexRows = await executor.all(`PRAGMA index_list(${name})`);
-    }
-    catch {
-        // A table with neither FKs nor indexes answers with zero rows on some drivers and raises on
-        // others; an unreadable constraint list must not hide the column list we already have.
-    }
-    const foreignKeys = fkRows
-        .map(row => ({
-        column: row.from,
-        targetTable: row.table,
-        targetColumn: row.to ?? 'id',
-        onDelete: String(row.on_delete ?? '').toUpperCase(),
-        onUpdate: String(row.on_update ?? '').toUpperCase(),
-    }))
-        .sort((a, b) => a.column.localeCompare(b.column) || a.targetTable.localeCompare(b.targetTable));
-    const indexes = indexRows
-        // Implicit indexes SQLite mints for UNIQUE/PK are not schema an author declared, and their
-        // names are not stable across environments.
-        .filter(row => !row.name.startsWith('sqlite_autoindex_'))
-        .map(row => ({ name: row.name, unique: row.unique === 1 }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-    return { name, exists: true, columns, foreignKeys, indexes };
-}
-/**
- * Names of the physical tables SQLite holds, optionally restricted to a `LIKE` prefix
- * (e.g. `content_`). Sorted, `sqlite_*` internals excluded.
- */
-export async function listTables(executor, prefix) {
-    if (prefix !== undefined)
-        assertSafeIdentifier(`${prefix}x`);
-    const filter = prefix ? ` AND name LIKE '${prefix}%'` : '';
-    const rows = await executor.all(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'${filter} ORDER BY name ASC`);
-    return rows.map(row => row.name);
-}
-/**
- * Physical state of several tables at once. With no explicit list, every `content_*` table is
- * introspected — the set a schema export or a drift check cares about.
- */
-export async function introspectSchema(executor, tables) {
-    const names = tables ?? await listTables(executor, 'content_');
-    const sorted = [...names].sort((a, b) => a.localeCompare(b));
-    const result = [];
-    // Sequential on purpose: the CLI executor is a synchronous shell/SQLite call behind a Promise,
-    // and D1 rejects unbounded concurrent statements from one request.
-    for (const name of sorted) {
-        result.push(await introspectTable(executor, name));
-    }
-    return { tables: result };
-}
-/**
- * The DECLARED schema: every active seed definition, read live from D1.
- *
- * This — not `beech.schema.ts` — is the source of truth for generated types and for the schema
- * fingerprint (feature brief, business rule 1). The manifest file is a desired-state artifact and
- * may legitimately be ahead of, or behind, what is deployed.
- */
-export async function introspectSeedDefinitions(executor) {
-    let rows;
-    try {
-        rows = await executor.all(`SELECT slug, definition FROM seeds WHERE status = 'active' ORDER BY slug ASC`);
-    }
-    catch (error) {
-        throw new IntrospectionError('Failed to read the `seeds` table from D1.', error);
-    }
-    return rows.map(row => {
-        try {
-            return JSON.parse(row.definition);
-        }
-        catch (error) {
-            throw new IntrospectionError(`Seed '${row.slug}' holds a definition that is not valid JSON; D1 state is corrupt.`, error);
-        }
-    });
-}

package/dist/engine/localization.d.ts

@@ -1,127 +0,0 @@
-/**
- * @module engine/localization
- * Field-level localization primitives for the Botanical Engine. A localized branch keeps its native
- * TEXT column and stores a locale dictionary in it (`{"it":"Scarpa","en":"Shoe"}`), so ids, relations
- * and metrics are untouched and toggling `Branch.localized` never emits DDL. Pure functions: no I/O and
- * no settings access — callers pass the project's {@link LocaleConfig}.
- */
-import type { Branch, BranchType, Seed } from './types.js';
-/**
- * Locale code grammar (v1): ISO 639 language (2–3 lowercase letters), optionally followed by an ISO 3166
- * region (2 uppercase letters) or a UN M.49 area (3 digits) — `it`, `en`, `pt-BR`, `es-419`. Script
- * subtags (`zh-Hant`) are outside v1. The grammar doubles as an injection guard: validated codes are
- * later interpolated into SQLite JSON paths.
- */
-export declare const LOCALE_CODE_RE: RegExp;
-/** Branch types that may carry `localized: true`. */
-export declare const LOCALIZABLE_BRANCH_TYPES: ReadonlySet<BranchType>;
-/**
- * Project-level language configuration. Invariant (guaranteed by its producer): `locales` is non-empty,
- * every entry matches {@link LOCALE_CODE_RE}, and it contains `defaultLocale`.
- */
-export interface LocaleConfig {
-    readonly locales: readonly string[];
-    readonly defaultLocale: string;
-}
-/** A locale dictionary as stored in the branch column: locale code → value. */
-export type LocalizedDictionary = Record<string, unknown>;
-/**
- * A validated write for a localized branch: registered locale code → new value, or `null` meaning
- * "clear this locale". Locales absent from the patch must be left untouched by the write path.
- */
-export type LocalizedPatch = Record<string, unknown>;
-/** True when `value` is a string matching {@link LOCALE_CODE_RE}. */
-export declare function isLocaleCode(value: unknown): value is string;
-/**
- * True when the branch is localized AND its type supports it. A malformed definition that slipped past
- * seed validation (e.g. `localized: true` on a `number`) is treated as not localized, never as a dictionary.
- */
-export declare function isLocalizedBranch(branch: Pick<Branch, 'type' | 'localized'>): boolean;
-/**
- * Structural check used on READ paths (no config available): a non-empty plain object whose every key
- * matches the locale-code grammar. A richtext envelope (`schemaVersion`, `doc`) and a TipTap doc
- * (`type`, `content`) never match.
- */
-export declare function isLocaleDictionary(value: unknown): value is LocalizedDictionary;
-/**
- * Stricter check used on WRITE paths: a locale dictionary with at least one REGISTERED locale key.
- * Without the registration requirement a legitimate json value such as `{"url": "…", "alt": "…"}` —
- * whose keys happen to match the grammar — would be read as a dictionary of unregistered locales and
- * silently emptied.
- */
-export declare function isLocalizedWriteDictionary(value: unknown, config: LocaleConfig): value is LocalizedDictionary;
-/**
- * Normalises any accepted write value of a localized branch into a {@link LocalizedPatch}:
- * - a write dictionary keeps its registered locales, in `config.locales` order; unregistered locale
- *   keys are dropped;
- * - any other value (string, richtext doc, non-dictionary json) is the default-locale value;
- * - `null`, `undefined` and blank strings become `null` ("clear this locale").
- * Idempotent: a patch passed back in yields the same patch.
- */
-export declare function toLocalizedPatch(value: unknown, config: LocaleConfig): LocalizedPatch;
-/**
- * Removes `null` / `undefined` / blank-string entries. Returns `null` when nothing remains, so an
- * all-cleared dictionary is stored as SQL NULL rather than `{}`. Keys are otherwise preserved as-is —
- * including locales no longer registered, which must never be dropped by a write (brief §2, no data loss).
- */
-export declare function compactLocalizedDictionary(value: LocalizedDictionary): LocalizedDictionary | null;
-/**
- * The settings subset {@link resolveLocaleConfig} reads. Structural, so this module stays free of
- * settings imports; `SiteSettings` satisfies it.
- */
-export interface LocaleSettings {
-    readonly locales?: readonly string[] | null;
-    readonly defaultLocale?: string | null;
-    readonly defaultLanguage: string;
-}
-/**
- * Builds the project's {@link LocaleConfig}, repairing whatever a hand-edited settings row could break so
- * the LocaleConfig invariant always holds:
- * - `locales`: the stored list minus invalid codes and duplicates; when nothing remains (never configured,
- *   `[]`, corrupt), the implicit single-language config `[defaultLanguage]` (brief §2), which keeps the
- *   feature invisible to a mono-lingual project;
- * - `defaultLocale`: the stored value when it belongs to `locales`, else `locales[0]`.
- */
-export declare function resolveLocaleConfig(settings: LocaleSettings): LocaleConfig;
-/**
- * Merges a write into the value stored for a localized branch. The write path's only way to persist a
- * localized value, so a translation the write does not mention is never dropped (brief §2):
- * - `write === null` clears the whole field (an explicit null keeps its pre-localization meaning);
- * - otherwise the write is normalised with {@link toLocalizedPatch}: every registered locale it names
- *   overwrites that locale, a `null` entry clears that locale only, and every other stored locale —
- *   including ones no longer registered — is kept as-is;
- * - a stored legacy value (written before the branch became localized) is the default-locale value.
- * @returns The compacted dictionary, or `null` when no locale keeps a value.
- */
-export declare function applyLocalizedPatch(branch: Pick<Branch, 'type' | 'localized'>, stored: unknown, write: unknown, config: LocaleConfig): LocalizedDictionary | null;
-/** Aliases of the localized branches a write carries — the fields it must merge rather than replace. */
-export declare function localizedAliasesIn(seed: Pick<Seed, 'branches'>, data: Record<string, unknown>): string[];
-/**
- * Returns `data` with every localized branch it carries merged into `stored` via
- * {@link applyLocalizedPatch}; other keys pass through untouched. `stored` is the entry's current values
- * (`null` on create, which only compacts). Returns `data` itself when `config` is undefined or no localized
- * branch is written.
- */
-export declare function mergeLocalizedFields(seed: Pick<Seed, 'branches'>, stored: Record<string, unknown> | null, data: Record<string, unknown>, config: LocaleConfig | undefined): Record<string, unknown>;
-/**
- * Resolves a stored localized value to one language: the requested locale, then the default locale, then the
- * first stored translation (stored key order), then `null`. A legacy value that is not a dictionary is returned
- * as-is. Non-localized branches return `value` unchanged. `buildSelectQuery` applies the same chain in SQL, so
- * filters and ORDER BY compare exactly what a reader sees.
- */
-export declare function resolveLocalizedValue(branch: Pick<Branch, 'type' | 'localized'>, value: unknown, locale: string, config: LocaleConfig): unknown;
-/**
- * Returns a copy of `data` with every localized branch resolved to `locale` (default: the default locale)
- * via {@link resolveLocalizedValue}. Returns `data` itself when `config` is undefined.
- */
-export declare function resolveLocalizedFields(seed: Pick<Seed, 'branches'>, data: Record<string, unknown>, config: LocaleConfig | undefined, locale?: string): Record<string, unknown>;
-/**
- * The whole dictionary of a stored localized value, for readers asking every language (`?lang=all`):
- * a stored dictionary as-is — unregistered locales included, nothing is hidden (brief §2) — a legacy
- * value as `{ [defaultLocale]: value }` (the write path's reading of it), a blank value as `null`.
- * Non-localized branches return `value` unchanged.
- */
-export declare function asLocaleDictionary(branch: Pick<Branch, 'type' | 'localized'>, value: unknown, config: LocaleConfig): unknown;
-/** Returns a copy of `data` with every localized branch it carries passed through {@link asLocaleDictionary}. */
-export declare function asLocaleDictionaries(seed: Pick<Seed, 'branches'>, data: Record<string, unknown>, config: LocaleConfig): Record<string, unknown>;
-//# sourceMappingURL=localization.d.ts.map

package/dist/engine/localization.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"localization.d.ts","sourceRoot":"","sources":["../../src/engine/localization.ts"],"names":[],"mappings":"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"}

package/dist/engine/localization.js

@@ -1,212 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-import { cleanString, isPlainObject } from './validation/primitives.js';
-/**
- * Locale code grammar (v1): ISO 639 language (2–3 lowercase letters), optionally followed by an ISO 3166
- * region (2 uppercase letters) or a UN M.49 area (3 digits) — `it`, `en`, `pt-BR`, `es-419`. Script
- * subtags (`zh-Hant`) are outside v1. The grammar doubles as an injection guard: validated codes are
- * later interpolated into SQLite JSON paths.
- */
-export const LOCALE_CODE_RE = /^[a-z]{2,3}(?:-(?:[A-Z]{2}|[0-9]{3}))?$/;
-/** Branch types that may carry `localized: true`. */
-export const LOCALIZABLE_BRANCH_TYPES = new Set(['text', 'richtext', 'json']);
-/** True when `value` is a string matching {@link LOCALE_CODE_RE}. */
-export function isLocaleCode(value) {
-    return typeof value === 'string' && LOCALE_CODE_RE.test(value);
-}
-/**
- * True when the branch is localized AND its type supports it. A malformed definition that slipped past
- * seed validation (e.g. `localized: true` on a `number`) is treated as not localized, never as a dictionary.
- */
-export function isLocalizedBranch(branch) {
-    return branch.localized === true && LOCALIZABLE_BRANCH_TYPES.has(branch.type);
-}
-/**
- * Structural check used on READ paths (no config available): a non-empty plain object whose every key
- * matches the locale-code grammar. A richtext envelope (`schemaVersion`, `doc`) and a TipTap doc
- * (`type`, `content`) never match.
- */
-export function isLocaleDictionary(value) {
-    if (!isPlainObject(value))
-        return false;
-    const keys = Object.keys(value);
-    return keys.length > 0 && keys.every(isLocaleCode);
-}
-/**
- * Stricter check used on WRITE paths: a locale dictionary with at least one REGISTERED locale key.
- * Without the registration requirement a legitimate json value such as `{"url": "…", "alt": "…"}` —
- * whose keys happen to match the grammar — would be read as a dictionary of unregistered locales and
- * silently emptied.
- */
-export function isLocalizedWriteDictionary(value, config) {
-    return isLocaleDictionary(value) && Object.keys(value).some((key) => config.locales.includes(key));
-}
-function isBlankLocaleValue(value) {
-    return value === null || value === undefined || (typeof value === 'string' && cleanString(value) === '');
-}
-/**
- * Normalises any accepted write value of a localized branch into a {@link LocalizedPatch}:
- * - a write dictionary keeps its registered locales, in `config.locales` order; unregistered locale
- *   keys are dropped;
- * - any other value (string, richtext doc, non-dictionary json) is the default-locale value;
- * - `null`, `undefined` and blank strings become `null` ("clear this locale").
- * Idempotent: a patch passed back in yields the same patch.
- */
-export function toLocalizedPatch(value, config) {
-    const source = isLocalizedWriteDictionary(value, config)
-        ? value
-        : { [config.defaultLocale]: value };
-    const patch = {};
-    for (const locale of config.locales) {
-        if (!Object.hasOwn(source, locale))
-            continue;
-        patch[locale] = isBlankLocaleValue(source[locale]) ? null : source[locale];
-    }
-    return patch;
-}
-/**
- * Removes `null` / `undefined` / blank-string entries. Returns `null` when nothing remains, so an
- * all-cleared dictionary is stored as SQL NULL rather than `{}`. Keys are otherwise preserved as-is —
- * including locales no longer registered, which must never be dropped by a write (brief §2, no data loss).
- */
-export function compactLocalizedDictionary(value) {
-    const compact = {};
-    for (const [locale, localeValue] of Object.entries(value)) {
-        if (isBlankLocaleValue(localeValue))
-            continue;
-        compact[locale] = localeValue;
-    }
-    return Object.keys(compact).length > 0 ? compact : null;
-}
-/** Content locale used when neither stored `locales` nor a valid `defaultLanguage` is available. */
-const FALLBACK_LOCALE = 'en';
-/**
- * Builds the project's {@link LocaleConfig}, repairing whatever a hand-edited settings row could break so
- * the LocaleConfig invariant always holds:
- * - `locales`: the stored list minus invalid codes and duplicates; when nothing remains (never configured,
- *   `[]`, corrupt), the implicit single-language config `[defaultLanguage]` (brief §2), which keeps the
- *   feature invisible to a mono-lingual project;
- * - `defaultLocale`: the stored value when it belongs to `locales`, else `locales[0]`.
- */
-export function resolveLocaleConfig(settings) {
-    const stored = [...new Set((settings.locales ?? []).filter(isLocaleCode))];
-    const implicit = isLocaleCode(settings.defaultLanguage) ? settings.defaultLanguage : FALLBACK_LOCALE;
-    const locales = stored.length > 0 ? stored : [implicit];
-    const defaultLocale = settings.defaultLocale && locales.includes(settings.defaultLocale)
-        ? settings.defaultLocale
-        : locales[0];
-    return { locales, defaultLocale };
-}
-/**
- * True when a STORED value of a localized branch is a locale dictionary. Text and richtext cannot hold an
- * object keyed only by locale codes for any other reason; json can (`{"url": "…", "alt": "…"}`), so a json
- * object counts only when at least one key is a registered locale — otherwise it is a legacy value written
- * before the branch became localized.
- */
-function isStoredLocaleDictionary(branch, value, config) {
-    if (!isLocalizedBranch(branch) || !isLocaleDictionary(value))
-        return false;
-    return branch.type !== 'json' || Object.keys(value).some((key) => config.locales.includes(key));
-}
-/**
- * Merges a write into the value stored for a localized branch. The write path's only way to persist a
- * localized value, so a translation the write does not mention is never dropped (brief §2):
- * - `write === null` clears the whole field (an explicit null keeps its pre-localization meaning);
- * - otherwise the write is normalised with {@link toLocalizedPatch}: every registered locale it names
- *   overwrites that locale, a `null` entry clears that locale only, and every other stored locale —
- *   including ones no longer registered — is kept as-is;
- * - a stored legacy value (written before the branch became localized) is the default-locale value.
- * @returns The compacted dictionary, or `null` when no locale keeps a value.
- */
-export function applyLocalizedPatch(branch, stored, write, config) {
-    if (write === null)
-        return null;
-    const merged = isStoredLocaleDictionary(branch, stored, config)
-        ? { ...stored }
-        : isBlankLocaleValue(stored) ? {} : { [config.defaultLocale]: stored };
-    Object.assign(merged, toLocalizedPatch(write, config));
-    return compactLocalizedDictionary(merged);
-}
-/** Aliases of the localized branches a write carries — the fields it must merge rather than replace. */
-export function localizedAliasesIn(seed, data) {
-    return seed.branches
-        .filter((branch) => isLocalizedBranch(branch) && Object.hasOwn(data, branch.alias) && data[branch.alias] !== undefined)
-        .map((branch) => branch.alias);
-}
-/**
- * Returns `data` with every localized branch it carries merged into `stored` via
- * {@link applyLocalizedPatch}; other keys pass through untouched. `stored` is the entry's current values
- * (`null` on create, which only compacts). Returns `data` itself when `config` is undefined or no localized
- * branch is written.
- */
-export function mergeLocalizedFields(seed, stored, data, config) {
-    if (!config)
-        return data;
-    const aliases = localizedAliasesIn(seed, data);
-    if (aliases.length === 0)
-        return data;
-    const merged = { ...data };
-    for (const branch of seed.branches) {
-        if (!aliases.includes(branch.alias))
-            continue;
-        merged[branch.alias] = applyLocalizedPatch(branch, stored?.[branch.alias], data[branch.alias], config);
-    }
-    return merged;
-}
-/**
- * Resolves a stored localized value to one language: the requested locale, then the default locale, then the
- * first stored translation (stored key order), then `null`. A legacy value that is not a dictionary is returned
- * as-is. Non-localized branches return `value` unchanged. `buildSelectQuery` applies the same chain in SQL, so
- * filters and ORDER BY compare exactly what a reader sees.
- */
-export function resolveLocalizedValue(branch, value, locale, config) {
-    if (!isStoredLocaleDictionary(branch, value, config))
-        return value;
-    if (!isBlankLocaleValue(value[locale]))
-        return value[locale];
-    if (!isBlankLocaleValue(value[config.defaultLocale]))
-        return value[config.defaultLocale];
-    // An implicit config follows `defaultLanguage`; changing it before languages are configured leaves every
-    // dictionary without its default key. Returning null there would blank the public site (brief §2).
-    const firstStored = Object.values(value).find((translation) => !isBlankLocaleValue(translation));
-    return firstStored ?? null;
-}
-/**
- * Returns a copy of `data` with every localized branch resolved to `locale` (default: the default locale)
- * via {@link resolveLocalizedValue}. Returns `data` itself when `config` is undefined.
- */
-export function resolveLocalizedFields(seed, data, config, locale) {
-    if (!config)
-        return data;
-    const target = locale ?? config.defaultLocale;
-    const resolved = { ...data };
-    for (const branch of seed.branches) {
-        if (isLocalizedBranch(branch) && Object.hasOwn(resolved, branch.alias)) {
-            resolved[branch.alias] = resolveLocalizedValue(branch, resolved[branch.alias], target, config);
-        }
-    }
-    return resolved;
-}
-/**
- * The whole dictionary of a stored localized value, for readers asking every language (`?lang=all`):
- * a stored dictionary as-is — unregistered locales included, nothing is hidden (brief §2) — a legacy
- * value as `{ [defaultLocale]: value }` (the write path's reading of it), a blank value as `null`.
- * Non-localized branches return `value` unchanged.
- */
-export function asLocaleDictionary(branch, value, config) {
-    if (!isLocalizedBranch(branch))
-        return value;
-    if (isStoredLocaleDictionary(branch, value, config))
-        return value;
-    return isBlankLocaleValue(value) ? null : { [config.defaultLocale]: value };
-}
-/** Returns a copy of `data` with every localized branch it carries passed through {@link asLocaleDictionary}. */
-export function asLocaleDictionaries(seed, data, config) {
-    const expanded = { ...data };
-    for (const branch of seed.branches) {
-        if (isLocalizedBranch(branch) && Object.hasOwn(expanded, branch.alias)) {
-            expanded[branch.alias] = asLocaleDictionary(branch, expanded[branch.alias], config);
-        }
-    }
-    return expanded;
-}

package/dist/engine/policies.d.ts

@@ -1,58 +0,0 @@
-import type { ActorContext, Branch, DataClassification, Seed } from './types.js';
-/**
- * Computes an un-salted SHA-256 hex digest of a string value.
- * Used for basic digest operations.
- * @param value - The raw string value to hash.
- * @returns A Promise resolving to a 64-character hex string.
- */
-export declare function sha256hex(value: string): Promise<string>;
-/**
- * Verifies if a candidate string matches a stored SHA-256 hash digest.
- * @param stored - The expected 64-character SHA-256 hex digest.
- * @param candidate - The raw candidate string to verify.
- * @returns A Promise resolving to true if candidate matches stored digest, false otherwise.
- */
-export declare function verifyHashField(stored: string, candidate: string): Promise<boolean>;
-/**
- * Resolved classification rules for a branch, bundling storage strategy and API visibility defaults.
- */
-export interface ResolvedClassification {
-    /** Canonical data classification tier. */
-    classification: DataClassification;
-    /** Storage mechanism at rest (`plain`, `encrypt` via AES-GCM, or `hash` via HMAC-SHA256). */
-    storage: 'plain' | 'encrypt' | 'hash';
-    /** Default visibility rule for unauthenticated public API endpoints (`full` or `hidden`). */
-    publicVisibility: 'full' | 'hidden';
-    /** Default visibility rule for authenticated API endpoints (`full` or `hidden`). */
-    authVisibility: 'full' | 'hidden';
-}
-/** Normalizes raw policy strings to canonical DataClassification enum. */
-export declare function normalizeClassification(raw?: string): DataClassification;
-/**
- * Resolves the 4-tier DataClassification for a branch, bundling its storage
- * strategy at rest and its API visibility rules (public vs auth context).
- * @param branch - The seed branch definition to inspect.
- * @returns The resolved classification details and visibility rules.
- */
-export declare function resolveClassification(branch: Branch): ResolvedClassification;
-/**
- * Resolves branch policies applying all defaults and classification rules.
- * @param branch - The seed branch definition to inspect.
- * @returns Complete required policies object for the branch.
- */
-export declare function resolvePolicies(branch: Branch): Required<NonNullable<Branch['policies']>>;
-/**
- * Filters entry payload fields based on the caller's {@link ActorContext} and branch classification tier.
- *
- * Rules:
- * - Public actor: receives `public` fields; `internal`, `confidential`, and `restricted` fields are omitted.
- * - Authenticated actor: receives `public`, `internal`, and `confidential` fields; `restricted` fields are ALWAYS omitted.
- * - System actor: receives all fields including `restricted` (used for internal worker/automation orchestration).
- *
- * @param data - Raw record fields object.
- * @param seed - Content type seed definition containing branch definitions.
- * @param actor - Context of the caller requesting the entry payload (defaults to authenticated).
- * @returns Filtered data record containing only authorized fields for the given actor context.
- */
-export declare function filterEntryForActor(data: Record<string, unknown>, seed: Seed, actor?: ActorContext): Record<string, unknown>;
-//# sourceMappingURL=policies.d.ts.map

package/dist/engine/policies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../../src/engine/policies.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEhF;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAK9D;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEzF;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,cAAc,EAAE,kBAAkB,CAAA;IAClC,6FAA6F;IAC7F,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA;IACrC,6FAA6F;IAC7F,gBAAgB,EAAE,MAAM,GAAG,QAAQ,CAAA;IACnC,oFAAoF;IACpF,cAAc,EAAE,MAAM,GAAG,QAAQ,CAAA;CAClC;AAED,0EAA0E;AAC1E,wBAAgB,uBAAuB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAQxE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,CAmC5E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CA2BzF;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,IAAI,EACV,KAAK,GAAE,YAAwC,GAC9C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgDzB"}