@texuli/core 0.1.0-next.0 → 0.1.0-next.2

package/dist/editor/tree.d.ts

@@ -0,0 +1,35 @@
+import { type EditorLoadOptions } from './load.js';
+import type { EditorInline, EditorIssue } from './types.js';
+/**
+ * The nested inline shape the sink-free renderers walk. Catalog rich text and
+ * blocks Markdown trees map to it one to one (`em`/`strong`/`link` nest;
+ * blocks call strike `del`, the catalog stores text in `value`).
+ */
+export type EditorInlineNode = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'code';
+    text: string;
+} | {
+    type: 'break';
+} | {
+    type: 'strong' | 'em' | 'strike';
+    children: EditorInlineNode[];
+} | {
+    type: 'link';
+    href: string;
+    children: EditorInlineNode[];
+};
+/** Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`, `strike`). */
+export declare function inlineToTree(content: readonly EditorInline[]): EditorInlineNode[];
+/**
+ * Flatten a nested inline tree (this shape, the catalog's or the blocks
+ * Markdown tree) into runs. Untrusted by default: every href passes
+ * `safeHref` at `trust` (a refused link keeps its text), nesting past 6
+ * levels becomes text, and unknown nodes keep their text. Never throws.
+ */
+export declare function inlineFromTree(nodes: unknown, options?: EditorLoadOptions): {
+    content: readonly EditorInline[];
+    diagnostics: readonly EditorIssue[];
+};

package/dist/editor/tree.js

@@ -0,0 +1,103 @@
+import { markKey, normalizeInline, sortMarks } from "./inline.js";
+import { LoadBudget } from "./load.js";
+/** Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`, `strike`). */
+export function inlineToTree(content) {
+    const root = [];
+    const stack = [];
+    const children = () => stack.at(-1)?.node.children ?? root;
+    for (const run of content) {
+        if (run.type === 'break') {
+            stack.length = 0;
+            root.push({ type: 'break' });
+            continue;
+        }
+        const wanted = run.marks.filter((mark) => mark.type !== 'code');
+        let common = 0;
+        while (common < stack.length &&
+            common < wanted.length &&
+            markKey(stack[common].mark) ===
+                markKey(wanted[common]))
+            common += 1;
+        stack.length = common;
+        for (const mark of wanted.slice(common)) {
+            const node = mark.type === 'link'
+                ? { type: 'link', href: mark.href, children: [] }
+                : { type: mark.type, children: [] };
+            children().push(node);
+            stack.push({ mark, node });
+        }
+        const code = run.marks.some((mark) => mark.type === 'code');
+        children().push({ type: code ? 'code' : 'text', text: run.text });
+    }
+    return root;
+}
+const TREE_DEPTH = 6;
+/** Plain text of a node, at most 64 levels down (deeper text is dropped). */
+function textOf(node, depth = 0) {
+    if (depth > 64 || typeof node !== 'object' || node === null)
+        return '';
+    const { text, value, children } = node;
+    if (typeof text === 'string')
+        return text;
+    if (typeof value === 'string')
+        return value;
+    return Array.isArray(children)
+        ? children
+            .slice(0, 4_096)
+            .map((child) => textOf(child, depth + 1))
+            .join('')
+        : '';
+}
+/**
+ * Flatten a nested inline tree (this shape, the catalog's or the blocks
+ * Markdown tree) into runs. Untrusted by default: every href passes
+ * `safeHref` at `trust` (a refused link keeps its text), nesting past 6
+ * levels becomes text, and unknown nodes keep their text. Never throws.
+ */
+export function inlineFromTree(nodes, options = {}) {
+    const budget = new LoadBudget(options);
+    const out = [];
+    const visit = (list, marks, depth) => {
+        if (!Array.isArray(list))
+            return;
+        for (const raw of list) {
+            if (typeof raw !== 'object' || raw === null)
+                continue;
+            const node = raw;
+            const text = typeof node.text === 'string'
+                ? node.text
+                : typeof node.value === 'string'
+                    ? node.value
+                    : undefined;
+            if (node.type === 'break') {
+                out.push({ type: 'break' });
+                continue;
+            }
+            if ((node.type === 'text' || node.type === 'code') && text !== undefined) {
+                out.push(...budget.inline(text, node.type === 'code' ? sortMarks([...marks, { type: 'code' }]) : marks));
+                continue;
+            }
+            if (depth >= TREE_DEPTH) {
+                budget.report('depth-capped', 'Inline nesting deeper than 6 levels became text.');
+                out.push(...budget.inline(textOf(node), marks));
+                continue;
+            }
+            const type = node.type === 'del' ? 'strike' : node.type;
+            if (type === 'strong' || type === 'em' || type === 'strike') {
+                visit(node.children, sortMarks([...marks, { type }]), depth + 1);
+            }
+            else if (type === 'link') {
+                const href = budget.href(node.href);
+                visit(node.children, href ? sortMarks([...marks, { type: 'link', href }]) : marks, depth + 1);
+            }
+            else {
+                budget.report('unknown-node', 'Unknown inline nodes kept only their text.');
+                if (text !== undefined)
+                    out.push(...budget.inline(text, marks));
+                visit(node.children, marks, depth + 1);
+            }
+        }
+    };
+    visit(nodes, [], 0);
+    return { content: normalizeInline(out), diagnostics: budget.diagnostics };
+}

package/dist/editor/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * The rich text editor document model, version 1 (ADR-003). Framework-free
+ * data: no DOM, no HTML. A document is a tree of blocks; text blocks hold
+ * flat runs of text with mark sets. Link hrefs are data here: they passed
+ * `safeHref` when they entered the model, and the binding renders them
+ * through the URL policy again.
+ */
+/** Runtime-only block id: assigned on load, never serialized. */
+export type EditorBlockId = string;
+export type EditorMark = {
+    type: 'strong';
+} | {
+    type: 'em';
+} | {
+    type: 'strike';
+} | {
+    type: 'code';
+} | {
+    type: 'link';
+    href: string;
+};
+export type EditorMarkType = EditorMark['type'];
+export type EditorInline = {
+    type: 'text';
+    text: string;
+    marks: readonly EditorMark[];
+} | {
+    type: 'break';
+};
+export type EditorHeadingLevel = 1 | 2 | 3 | 4;
+export type EditorParagraph = {
+    id: EditorBlockId;
+    type: 'paragraph';
+    content: readonly EditorInline[];
+};
+export type EditorHeading = {
+    id: EditorBlockId;
+    type: 'heading';
+    level: EditorHeadingLevel;
+    content: readonly EditorInline[];
+};
+export type EditorCodeBlock = {
+    id: EditorBlockId;
+    type: 'code';
+    lang?: string;
+    text: string;
+};
+/** Blocks that hold inline content (marks allowed). */
+export type EditorRichBlock = EditorParagraph | EditorHeading;
+/** Blocks a caret can be in. */
+export type EditorTextBlock = EditorRichBlock | EditorCodeBlock;
+export type EditorListKind = 'bullet' | 'ordered' | 'todo';
+export type EditorListItem = {
+    id: EditorBlockId;
+    /** Todo lists only. */
+    checked?: boolean;
+    /** The first block is always a paragraph. */
+    blocks: readonly EditorBlock[];
+};
+export type EditorList = {
+    id: EditorBlockId;
+    type: 'list';
+    kind: EditorListKind;
+    /** Ordered lists only; 1 when omitted. */
+    start?: number;
+    items: readonly EditorListItem[];
+};
+export type EditorQuote = {
+    id: EditorBlockId;
+    type: 'quote';
+    blocks: readonly EditorBlock[];
+};
+export type EditorDivider = {
+    id: EditorBlockId;
+    type: 'divider';
+};
+/** A host-resolved media reference; the model never loads it. */
+export type EditorMedia = {
+    id: EditorBlockId;
+    type: 'media';
+    ref: string;
+    alt: string;
+};
+export type EditorBlock = EditorTextBlock | EditorList | EditorQuote | EditorDivider | EditorMedia;
+export type EditorBlockType = EditorBlock['type'];
+export type EditorDocument = {
+    version: 1;
+    blocks: readonly EditorBlock[];
+};
+/** A caret position: a text block and a UTF-16 offset into its text (a break counts 1). */
+export type EditorPoint = {
+    block: EditorBlockId;
+    offset: number;
+};
+export type EditorSelection = {
+    kind: 'text';
+    anchor: EditorPoint;
+    focus: EditorPoint;
+} | {
+    kind: 'node';
+    block: EditorBlockId;
+};
+/** What transforms and history work on. */
+export interface EditorState {
+    doc: EditorDocument;
+    selection: EditorSelection;
+    /** Marks the next typed text gets (set by a mark toggle at a caret). */
+    storedMarks?: readonly EditorMark[] | null;
+}
+export type EditorIssueCode = 'invalid-shape' | 'unknown-node' | 'unknown-mark' | 'version-unsupported' | 'depth-capped' | 'blocks-capped' | 'text-truncated' | 'link-rejected' | 'mark-dropped' | 'characters-stripped' | 'heading-clamped' | 'not-normalized' | 'duplicate-id' | 'invalid-selection' | 'not-allowed-here' | 'nothing-to-do' | 'limit-reached';
+export interface EditorIssue {
+    code: EditorIssueCode;
+    message: string;
+    /** The block concerned, when there is one. */
+    block?: EditorBlockId;
+}
+export type EditorTransformResult = {
+    ok: true;
+    state: EditorState;
+    diagnostics?: readonly EditorIssue[];
+} | {
+    ok: false;
+    errors: readonly EditorIssue[];
+};
+/** Caps: hostile input degrades (diagnostics), never throws or recurses without bound. */
+export declare const EDITOR_LIMITS: Readonly<{
+    /** Blocks in a document, containers included. */
+    blocks: 2000;
+    /** Characters of text in a document. */
+    chars: 200000;
+    /** Nested lists and quotes around a block. */
+    depth: 4;
+    /** Longest link href or media ref kept. */
+    href: 2048;
+    /** Longest code block language name. */
+    lang: 32;
+    /** History snapshots kept. */
+    history: 200;
+}>;
+export type EditorLimits = {
+    blocks: number;
+    chars: number;
+    depth: number;
+};
+/** Canonical mark order: a run's marks are always sorted this way. */
+export declare const EDITOR_MARK_ORDER: readonly EditorMarkType[];
+export declare const EDITOR_BLOCK_TYPES: readonly EditorBlockType[];

package/dist/editor/types.js

@@ -0,0 +1,39 @@
+/**
+ * The rich text editor document model, version 1 (ADR-003). Framework-free
+ * data: no DOM, no HTML. A document is a tree of blocks; text blocks hold
+ * flat runs of text with mark sets. Link hrefs are data here: they passed
+ * `safeHref` when they entered the model, and the binding renders them
+ * through the URL policy again.
+ */
+/** Caps: hostile input degrades (diagnostics), never throws or recurses without bound. */
+export const EDITOR_LIMITS = Object.freeze({
+    /** Blocks in a document, containers included. */
+    blocks: 2_000,
+    /** Characters of text in a document. */
+    chars: 200_000,
+    /** Nested lists and quotes around a block. */
+    depth: 4,
+    /** Longest link href or media ref kept. */
+    href: 2_048,
+    /** Longest code block language name. */
+    lang: 32,
+    /** History snapshots kept. */
+    history: 200,
+});
+/** Canonical mark order: a run's marks are always sorted this way. */
+export const EDITOR_MARK_ORDER = [
+    'link',
+    'strong',
+    'em',
+    'strike',
+    'code',
+];
+export const EDITOR_BLOCK_TYPES = [
+    'paragraph',
+    'heading',
+    'code',
+    'list',
+    'quote',
+    'divider',
+    'media',
+];

package/dist/index.d.ts

@@ -23,3 +23,4 @@ export { safeImageSrc } from './url-policy/safe-image-src.js';
 export { safeImageSrcset } from './url-policy/safe-image-srcset.js';
 export { type SafeMediaSrcOptions, safeMediaSrc } from './url-policy/safe-media-src.js';
 export { MAX_DATA_IMAGE_BYTES } from './url-policy/shared.js';
+export { resolveTrust } from './url-policy/trust.js';

package/dist/index.js

@@ -22,3 +22,4 @@ export { safeImageSrc } from "./url-policy/safe-image-src.js";
 export { safeImageSrcset } from "./url-policy/safe-image-srcset.js";
 export { safeMediaSrc } from "./url-policy/safe-media-src.js";
 export { MAX_DATA_IMAGE_BYTES } from "./url-policy/shared.js";
+export { resolveTrust } from "./url-policy/trust.js";

package/dist/url/safe-href.d.ts

@@ -1,22 +1,3 @@
-/**
- * URL policy for every link a Texuli component renders.
- *
- * Two trust tiers:
- * - `developer`: props written by the app's own developers. Every scheme is
- *   allowed except the ones that execute or smuggle content: `javascript:`,
- *   `vbscript:`, `data:` and protocol-relative `//host` URLs.
- * - `untrusted`: content an agent or a user produced. Only `https:`,
- *   `mailto:` and same-document `#fragment` links pass, and additionally:
- *   - no invisible formatting characters anywhere (zero-width, bidi
- *     overrides and isolates, BOM, soft hyphen): they make a link read
- *     differently from where it goes;
- *   - `https:` links use the authority form (`https://host`) and parse to a
- *     host, so `https:evil.example` is refused;
- *   - no credentials before the host (`https://bank.example@evil.example`
- *     shows a trusted name while it opens another origin).
- *
- * A rejected value returns `undefined`, so the caller renders inert text.
- */
 export type HrefTrust = 'developer' | 'untrusted';
 /**
  * Whether `value` holds an invisible formatting character: soft hyphen,
@@ -25,4 +6,4 @@ export type HrefTrust = 'developer' | 'untrusted';
  * operators, or a byte-order mark. Checked by code point.
  */
 export declare function hasInvisibleFormatting(value: string): boolean;
-export declare function safeHref(value: unknown, trust?: HrefTrust): string | undefined;
+export declare function safeHref(value: unknown, requested?: HrefTrust): string | undefined;

package/dist/url/safe-href.js

@@ -1,3 +1,28 @@
+/**
+ * URL policy for every link a Texuli component renders.
+ *
+ * Two trust tiers:
+ * - `developer`: props written by the app's own developers. Every scheme is
+ *   allowed except the ones that execute or smuggle content: `javascript:`,
+ *   `vbscript:`, `data:` and protocol-relative URLs: any value opening with
+ *   two of `/` and `\` (`//host`, `/\host`, `\/host`, `\\host`) or with a
+ *   backslash.
+ * - `untrusted`: content an agent or a user produced. Only `https:`,
+ *   `mailto:` and same-document `#fragment` links pass, and additionally:
+ *   - no invisible formatting characters anywhere (zero-width, bidi
+ *     overrides and isolates, BOM, soft hyphen): they make a link read
+ *     differently from where it goes;
+ *   - `https:` links use the authority form (`https://host`) and parse to a
+ *     host, so `https:evil.example` is refused;
+ *   - no credentials before the host (`https://bank.example@evil.example`
+ *     shows a trusted name while it opens another origin).
+ *
+ * Any trust value other than the exact string `'developer'` is treated as
+ * `untrusted` (`resolveTrust`). A rejected value returns `undefined`, so the
+ * caller renders inert text.
+ */
+import { hasAuthorityPrefix } from "../url-policy/shared.js";
+import { resolveTrust } from "../url-policy/trust.js";
 const BLOCKED_SCHEMES = new Set(['javascript:', 'vbscript:', 'data:']);
 const UNTRUSTED_SCHEMES = new Set(['https:', 'mailto:']);
 /**
@@ -32,7 +57,8 @@ function isPlainHttpsLink(href) {
         return false;
     }
 }
-export function safeHref(value, trust = 'untrusted') {
+export function safeHref(value, requested = 'untrusted') {
+    const trust = resolveTrust(requested);
     if (typeof value !== 'string')
         return undefined;
     // Browsers drop ASCII whitespace and control characters inside a scheme.
@@ -44,7 +70,8 @@ export function safeHref(value, trust = 'untrusted') {
         return undefined;
     if (href.startsWith('#'))
         return href;
-    if (href.startsWith('//') || href.startsWith('\\'))
+    // `//`, `/\`, `\/` and `\\` all open another origin; so does any leading `\`.
+    if (hasAuthorityPrefix(href))
         return undefined;
     const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(href)?.[1]?.toLowerCase();
     if (trust === 'untrusted') {

package/dist/url-policy/index.d.ts

@@ -3,3 +3,4 @@ export { safeImageSrc } from './safe-image-src.js';
 export { safeImageSrcset } from './safe-image-srcset.js';
 export { type SafeMediaSrcOptions, safeMediaSrc } from './safe-media-src.js';
 export { MAX_DATA_IMAGE_BYTES } from './shared.js';
+export { resolveTrust } from './trust.js';

package/dist/url-policy/index.js

@@ -3,3 +3,4 @@ export { safeImageSrc } from "./safe-image-src.js";
 export { safeImageSrcset } from "./safe-image-srcset.js";
 export { safeMediaSrc } from "./safe-media-src.js";
 export { MAX_DATA_IMAGE_BYTES } from "./shared.js";
+export { resolveTrust } from "./trust.js";

package/dist/url-policy/safe-image-src.d.ts

@@ -4,4 +4,4 @@ import { type HrefTrust } from '../url/safe-href.js';
  * relative asset path; developer-authored images may also use HTTP, blob URLs,
  * or a bounded base64 raster data image. Unsafe values return `undefined`.
  */
-export declare function safeImageSrc(value: unknown, trust?: HrefTrust): string | undefined;
+export declare function safeImageSrc(value: unknown, requested?: HrefTrust): string | undefined;

package/dist/url-policy/safe-image-src.js

@@ -1,5 +1,6 @@
 import { hasInvisibleFormatting } from "../url/safe-href.js";
-import { cleanSource, isAllowedRelativeOrWebSource, isBlockedSource, isSafeDataImage, isValidBlobSource, isValidTrust, sourceScheme, } from "./shared.js";
+import { cleanSource, isAllowedRelativeOrWebSource, isBlockedSource, isSafeDataImage, isValidBlobSource, sourceScheme, } from "./shared.js";
+import { resolveTrust } from "./trust.js";
 /**
  * A relative image path an agent may use: no invisible formatting
  * characters, and no colon in its first segment. RFC 3986 already requires
@@ -20,9 +21,8 @@ function isPlainRelativePath(source) {
  * relative asset path; developer-authored images may also use HTTP, blob URLs,
  * or a bounded base64 raster data image. Unsafe values return `undefined`.
  */
-export function safeImageSrc(value, trust = 'untrusted') {
-    if (!isValidTrust(trust))
-        return undefined;
+export function safeImageSrc(value, requested = 'untrusted') {
+    const trust = resolveTrust(requested);
     if (typeof value === 'string') {
         const dataSource = value.trim();
         if (sourceScheme(dataSource) === 'data') {

package/dist/url-policy/safe-image-srcset.d.ts

@@ -4,4 +4,4 @@ import type { HrefTrust } from '../url/safe-href.js';
  * standard comma-separated URL plus optional `x` or `w` descriptor form. If
  * any part is malformed or unsafe, the entire value returns `undefined`.
  */
-export declare function safeImageSrcset(value: unknown, trust?: HrefTrust): string | undefined;
+export declare function safeImageSrcset(value: unknown, requested?: HrefTrust): string | undefined;

package/dist/url-policy/safe-image-srcset.js

@@ -1,10 +1,12 @@
 import { safeImageSrc } from "./safe-image-src.js";
+import { resolveTrust } from "./trust.js";
 /**
  * Validate every URL and descriptor in an image `srcset`. Candidates use the
  * standard comma-separated URL plus optional `x` or `w` descriptor form. If
  * any part is malformed or unsafe, the entire value returns `undefined`.
  */
-export function safeImageSrcset(value, trust = 'untrusted') {
+export function safeImageSrcset(value, requested = 'untrusted') {
+    const trust = resolveTrust(requested);
     if (typeof value !== 'string' || value.trim() === '' || value.length > 16_384)
         return undefined;
     const candidates = value.split(',').map((candidate) => candidate.trim());

package/dist/url-policy/safe-media-src.d.ts

@@ -9,4 +9,4 @@ export type SafeMediaSrcOptions = {
  * come from an explicitly allowlisted HTTPS origin. Developer media may also
  * use HTTP and relative asset paths. `data:` is never accepted for media.
  */
-export declare function safeMediaSrc(value: unknown, trust?: HrefTrust, options?: SafeMediaSrcOptions): string | undefined;
+export declare function safeMediaSrc(value: unknown, requested?: HrefTrust, options?: SafeMediaSrcOptions): string | undefined;

package/dist/url-policy/safe-media-src.js

@@ -1,12 +1,12 @@
-import { cleanSource, isBlockedSource, isValidBlobSource, isValidTrust, normalizedHttpsOrigins, sourceScheme, } from "./shared.js";
+import { cleanSource, isBlockedSource, isValidBlobSource, normalizedHttpsOrigins, sourceScheme, } from "./shared.js";
+import { resolveTrust } from "./trust.js";
 /**
  * Validate a URL for audio or video. Untrusted media must be a blob URL or
  * come from an explicitly allowlisted HTTPS origin. Developer media may also
  * use HTTP and relative asset paths. `data:` is never accepted for media.
  */
-export function safeMediaSrc(value, trust = 'untrusted', options = {}) {
-    if (!isValidTrust(trust))
-        return undefined;
+export function safeMediaSrc(value, requested = 'untrusted', options = {}) {
+    const trust = resolveTrust(requested);
     const source = cleanSource(value);
     if (!source || isBlockedSource(source))
         return undefined;

package/dist/url-policy/shared.d.ts

@@ -1,10 +1,16 @@
-import type { HrefTrust } from '../url/safe-href.js';
 export declare function cleanSource(value: unknown): string | undefined;
+/**
+ * Whether a URL opens with a backslash or with `//` or `/\`. Browsers read
+ * `\` as `/` in http(s) URLs, so `//host`, `/\host`, `\/host` and `\\host`
+ * are all protocol-relative and leave the page's origin (`/\evil.example`
+ * resolves to `https://evil.example/`). Callers pass the value after
+ * trimming and stripping control characters.
+ */
+export declare function hasAuthorityPrefix(value: string): boolean;
 export declare function sourceScheme(value: string): string | undefined;
 export declare function isBlockedSource(value: string): boolean;
 export declare function isAllowedRelativeOrWebSource(value: string): boolean;
 export declare function isValidBlobSource(value: string): boolean;
-export declare function isValidTrust(trust: HrefTrust): boolean;
 export declare function normalizedHttpsOrigins(origins: readonly string[] | undefined): Set<string>;
 export declare function isSafeDataImage(value: string): boolean;
 /** Maximum decoded size of a developer-authored base64 data image. */

package/dist/url-policy/shared.js

@@ -11,14 +11,22 @@ export function cleanSource(value) {
     }
     return source;
 }
+/**
+ * Whether a URL opens with a backslash or with `//` or `/\`. Browsers read
+ * `\` as `/` in http(s) URLs, so `//host`, `/\host`, `\/host` and `\\host`
+ * are all protocol-relative and leave the page's origin (`/\evil.example`
+ * resolves to `https://evil.example/`). Callers pass the value after
+ * trimming and stripping control characters.
+ */
+export function hasAuthorityPrefix(value) {
+    return /^(\\|\/[/\\])/.test(value);
+}
 export function sourceScheme(value) {
     return /^([a-z][a-z0-9+.-]*):/i.exec(value)?.[1]?.toLowerCase();
 }
 export function isBlockedSource(value) {
     const scheme = sourceScheme(value);
-    return ((scheme !== undefined && BLOCKED_SCHEMES.has(`${scheme}:`)) ||
-        value.startsWith('//') ||
-        value.startsWith('\\'));
+    return (scheme !== undefined && BLOCKED_SCHEMES.has(`${scheme}:`)) || hasAuthorityPrefix(value);
 }
 export function isAllowedRelativeOrWebSource(value) {
     const scheme = sourceScheme(value);
@@ -45,9 +53,6 @@ export function isValidBlobSource(value) {
         return false;
     }
 }
-export function isValidTrust(trust) {
-    return trust === 'developer' || trust === 'untrusted';
-}
 export function normalizedHttpsOrigins(origins) {
     const normalized = new Set();
     if (!origins)

package/dist/url-policy/trust.d.ts

@@ -0,0 +1,8 @@
+import type { HrefTrust } from '../url/safe-href.js';
+/**
+ * The trust tier a caller asked for, failing closed: only the exact string
+ * `'developer'` is the developer tier. Anything else (another case, an empty
+ * string, `null`, a value read from config) is `'untrusted'`. Every URL policy
+ * entry point resolves its tier through this one rule.
+ */
+export declare function resolveTrust(value: unknown): HrefTrust;

package/dist/url-policy/trust.js

@@ -0,0 +1,9 @@
+/**
+ * The trust tier a caller asked for, failing closed: only the exact string
+ * `'developer'` is the developer tier. Anything else (another case, an empty
+ * string, `null`, a value read from config) is `'untrusted'`. Every URL policy
+ * entry point resolves its tier through this one rule.
+ */
+export function resolveTrust(value) {
+    return value === 'developer' ? 'developer' : 'untrusted';
+}

package/package.json

@@ -1,8 +1,23 @@
 {
   "name": "@texuli/core",
-  "version": "0.1.0-next.0",
+  "version": "0.1.0-next.2",
   "description": "Texels: framework-free behavior and policy that every Texuli component is built from.",
+  "keywords": [
+    "svelte",
+    "svelte-5",
+    "components",
+    "design-system",
+    "texuli"
+  ],
+  "homepage": "https://github.com/DailybotHQ/texuli#readme",
+  "bugs": "https://github.com/DailybotHQ/texuli/issues",
   "license": "MIT",
+  "author": "Dailybot, Inc.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DailybotHQ/texuli.git",
+    "directory": "packages/core"
+  },
   "type": "module",
   "sideEffects": [
     "**/*.css"
@@ -13,6 +28,11 @@
     "./controllable": "./dist/controllable/controllable-state.js",
     "./dir-locale": "./dist/dir-locale/dir-locale.js",
     "./dismiss": "./dist/dismiss/index.js",
+    "./editor-history": "./dist/editor/history.js",
+    "./editor-keymap": "./dist/editor/keymap.js",
+    "./editor-markdown": "./dist/editor/markdown.js",
+    "./editor-model": "./dist/editor/model.js",
+    "./editor-transforms": "./dist/editor/edit.js",
     "./env": "./dist/env/index.js",
     "./focus-scope": "./dist/focus-scope/index.js",
     "./form-bridge": "./dist/form-bridge/form-bridge.js",
@@ -34,9 +54,5 @@
   },
   "files": [
     "dist"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "tag": "next"
-  }
+  ]
 }