@veryfront/ext-content-mdx 0.1.1185 → 0.1.1188

package/esm/src/errors/diagnostic-policy.js

@@ -0,0 +1,100 @@
+import { sanitizeLogText } from "../utils/logger/core.js";
+import { REDACTED, sanitizeUrlCredentials } from "../utils/logger/redact.js";
+/** Maximum characters retained from one diagnostic field. */
+export const ERROR_DIAGNOSTIC_MAX_LENGTH_CHARS = 2_048;
+/** Maximum characters retained from a stack snapshot. */
+export const ERROR_STACK_MAX_LENGTH_CHARS = 8_192;
+/** Maximum characters retained from serialized structured error context. */
+export const ERROR_CONTEXT_MAX_LENGTH_CHARS = 4_096;
+/** Maximum characters emitted by one rendered error payload or terminal block. */
+export const ERROR_OUTPUT_MAX_LENGTH_CHARS = 64 * 1_024;
+/** Maximum source characters accepted for the error-docs path segment. */
+export const ERROR_DOCS_SLUG_MAX_LENGTH_CHARS = 256;
+export const ERROR_DOCS_BASE_URL = "https://veryfront.com/docs/errors/";
+const TRUNCATION_MARKER = "...[truncated]";
+const UNKNOWN_ERROR_SLUG = "unknown-error";
+function truncateDiagnosticText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    const prefixLength = Math.max(0, maxLength - TRUNCATION_MARKER.length);
+    const prefix = takeSafePrefix(value, prefixLength);
+    return `${prefix}${TRUNCATION_MARKER}`;
+}
+function takeSafePrefix(value, length) {
+    let prefix = value.slice(0, length);
+    const finalCodeUnit = prefix.charCodeAt(prefix.length - 1);
+    if (finalCodeUnit >= 0xd800 && finalCodeUnit <= 0xdbff) {
+        prefix = prefix.slice(0, -1);
+    }
+    return prefix;
+}
+function replaceLoneSurrogates(value) {
+    let result = "";
+    for (let index = 0; index < value.length; index++) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const nextCodeUnit = value.charCodeAt(index + 1);
+            if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {
+                result += value.slice(index, index + 2);
+                index++;
+            }
+            else {
+                result += "\ufffd";
+            }
+            continue;
+        }
+        result += codeUnit >= 0xdc00 && codeUnit <= 0xdfff ? "\ufffd" : value.charAt(index);
+    }
+    return result;
+}
+/**
+ * Redact a complete diagnostic before truncating it.
+ *
+ * The order is security-sensitive: truncating first could split a credential
+ * assignment before the redactor sees its complete value and expose a prefix.
+ */
+export function sanitizeBoundedDiagnosticText(value) {
+    if (typeof value !== "string")
+        return REDACTED;
+    return truncateDiagnosticText(sanitizeUrlCredentials(value), ERROR_DIAGNOSTIC_MAX_LENGTH_CHARS);
+}
+/** Redact and bound a stack while retaining its line structure. */
+export function sanitizeBoundedStackText(value) {
+    if (typeof value !== "string")
+        return REDACTED;
+    return truncateDiagnosticText(sanitizeUrlCredentials(value), ERROR_STACK_MAX_LENGTH_CHARS);
+}
+/** Redact, neutralize terminal controls, and bound one terminal field. */
+export function sanitizeBoundedTerminalText(value) {
+    const redacted = typeof value === "string" ? sanitizeUrlCredentials(value) : REDACTED;
+    if (redacted.length <= ERROR_DIAGNOSTIC_MAX_LENGTH_CHARS) {
+        return sanitizeLogText(redacted);
+    }
+    const prefixLength = ERROR_DIAGNOSTIC_MAX_LENGTH_CHARS -
+        TRUNCATION_MARKER.length;
+    return `${sanitizeLogText(takeSafePrefix(redacted, prefixLength))}${TRUNCATION_MARKER}`;
+}
+/**
+ * Bound a complete rendered terminal block.
+ *
+ * Normal-sized output retains framework styling. Oversized output is flattened
+ * through the terminal sanitizer before truncation so a cut cannot leave an
+ * incomplete ANSI sequence active in the caller's terminal.
+ */
+export function limitRenderedErrorOutput(value) {
+    if (value.length <= ERROR_OUTPUT_MAX_LENGTH_CHARS)
+        return value;
+    return truncateDiagnosticText(sanitizeLogText(value), ERROR_OUTPUT_MAX_LENGTH_CHARS);
+}
+/** Redact and bound an error identity consistently across every boundary. */
+export function sanitizeBoundedErrorSlug(slug) {
+    const sanitized = typeof slug === "string" ? sanitizeUrlCredentials(slug) : UNKNOWN_ERROR_SLUG;
+    const bounded = truncateDiagnosticText(sanitized || UNKNOWN_ERROR_SLUG, ERROR_DOCS_SLUG_MAX_LENGTH_CHARS);
+    const normalized = replaceLoneSurrogates(bounded);
+    return normalized === "." || normalized === ".." ? UNKNOWN_ERROR_SLUG : normalized;
+}
+/** Build a single, encoded, credential-scrubbed error documentation path. */
+export function buildErrorDocsUrl(slug) {
+    const segment = encodeURIComponent(sanitizeBoundedErrorSlug(slug));
+    return `${ERROR_DOCS_BASE_URL}${segment}`;
+}

package/esm/src/errors/error-registry/boundary.d.ts

@@ -4,6 +4,7 @@ export declare const CLIENT_ONLY_IN_SERVER: import("../types.js").RegisteredErro
 export declare const INVALID_USE_CLIENT: import("../types.js").RegisteredError;
 export declare const INVALID_USE_SERVER: import("../types.js").RegisteredError;
 export declare const RSC_PAYLOAD_ERROR: import("../types.js").RegisteredError;
+export declare const SSR_OUTPUT_LIMIT_EXCEEDED: import("../types.js").RegisteredError;
 /** Registry fragment for BOUNDARY errors (slug → definition). */
 export declare const BOUNDARY_REGISTRY: {
     readonly "client-boundary-violation": import("../types.js").RegisteredError;
@@ -12,5 +13,6 @@ export declare const BOUNDARY_REGISTRY: {
     readonly "invalid-use-client": import("../types.js").RegisteredError;
     readonly "invalid-use-server": import("../types.js").RegisteredError;
     readonly "rsc-payload-error": import("../types.js").RegisteredError;
+    readonly "ssr-output-limit-exceeded": import("../types.js").RegisteredError;
 };
 //# sourceMappingURL=boundary.d.ts.map

package/esm/src/errors/error-registry/boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/boundary.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,uCAMpC,CAAC;AAEH,eAAO,MAAM,qBAAqB,uCAMhC,CAAC;AAEH,eAAO,MAAM,qBAAqB,uCAMhC,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,iBAAiB;;;;;;;CAOpB,CAAC"}
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/boundary.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,uCAMpC,CAAC;AAEH,eAAO,MAAM,qBAAqB,uCAMhC,CAAC;AAEH,eAAO,MAAM,qBAAqB,uCAMhC,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,eAAO,MAAM,yBAAyB,uCAMpC,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,iBAAiB;;;;;;;;CAQpB,CAAC"}

package/esm/src/errors/error-registry/boundary.js

@@ -41,6 +41,13 @@ export const RSC_PAYLOAD_ERROR = defineError({
     title: "RSC payload serialization error",
     suggestion: "Ensure props are serializable (no functions, symbols, etc.)",
 });
+export const SSR_OUTPUT_LIMIT_EXCEEDED = defineError({
+    slug: "ssr-output-limit-exceeded",
+    category: "BOUNDARY",
+    status: 500,
+    title: "SSR output limit exceeded",
+    suggestion: "Reduce the rendered HTML size or split the response into smaller pages",
+});
 /** Registry fragment for BOUNDARY errors (slug → definition). */
 export const BOUNDARY_REGISTRY = {
     "client-boundary-violation": CLIENT_BOUNDARY_VIOLATION,
@@ -49,4 +56,5 @@ export const BOUNDARY_REGISTRY = {
     "invalid-use-client": INVALID_USE_CLIENT,
     "invalid-use-server": INVALID_USE_SERVER,
     "rsc-payload-error": RSC_PAYLOAD_ERROR,
+    "ssr-output-limit-exceeded": SSR_OUTPUT_LIMIT_EXCEEDED,
 };

package/esm/src/errors/error-registry/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/config.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,uCAM3B,CAAC;AAEH,eAAO,MAAM,cAAc,uCAMzB,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,uCAMlC,CAAC;AAEH,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,uEAAuE;AACvE,eAAO,MAAM,wBAAwB,uCAMnC,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,sBAAsB,uCAMjC,CAAC;AAEH,iGAAiG;AACjG,eAAO,MAAM,uBAAuB,uCAOlC,CAAC;AAEH,oEAAoE;AACpE,eAAO,MAAM,sBAAsB,uCAOjC,CAAC;AAEH,+DAA+D;AAC/D,eAAO,MAAM,eAAe;;;;;;;;;;;;CAYlB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/config.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,uCAO3B,CAAC;AAEH,eAAO,MAAM,cAAc,uCAMzB,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,uCAMlC,CAAC;AAEH,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,uEAAuE;AACvE,eAAO,MAAM,wBAAwB,uCAMnC,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,sBAAsB,uCAMjC,CAAC;AAEH,iGAAiG;AACjG,eAAO,MAAM,uBAAuB,uCAOlC,CAAC;AAEH,oEAAoE;AACpE,eAAO,MAAM,sBAAsB,uCAOjC,CAAC;AAEH,+DAA+D;AAC/D,eAAO,MAAM,eAAe;;;;;;;;;;;;CAYlB,CAAC"}

package/esm/src/errors/error-registry/config.js

@@ -4,21 +4,21 @@ export const CONFIG_NOT_FOUND = defineError({
     category: "CONFIG",
     status: 404,
     title: "Configuration file not found",
-    suggestion: "Run 'vf init' to create a configuration file",
+    suggestion: "Create veryfront.config.js, veryfront.config.ts, or veryfront.config.mjs in the project root",
 });
 export const CONFIG_INVALID = defineError({
     slug: "config-invalid",
     category: "CONFIG",
     status: 400,
     title: "Invalid configuration format",
-    suggestion: "Check your veryfront.config.ts for syntax errors",
+    suggestion: "Check the reported configuration path and validation details",
 });
 export const CONFIG_PARSE_ERROR = defineError({
     slug: "config-parse-error",
     category: "CONFIG",
     status: 400,
     title: "Failed to parse configuration",
-    suggestion: "Ensure your configuration file is valid TypeScript/JSON",
+    suggestion: "Ensure your configuration file contains valid JavaScript or TypeScript",
 });
 /** Schema-level config validation (e.g. Zod schema mismatch at runtime) */
 export const CONFIG_VALIDATION_ERROR = defineError({

package/esm/src/errors/error-registry/deploy.js

@@ -25,7 +25,7 @@ export const PRODUCTION_BUILD_REQUIRED = defineError({
     category: "DEPLOY",
     status: 400,
     title: "Production build required",
-    suggestion: "Run 'vf build' before deploying",
+    suggestion: "Run 'veryfront build' before deploying",
 });
 export const ENVIRONMENT_NOT_FOUND = defineError({
     slug: "environment-not-found",

package/esm/src/errors/error-registry/server.d.ts

@@ -4,6 +4,7 @@ export declare const CACHE_ERROR: import("../types.js").RegisteredError;
 export declare const FILE_WATCH_ERROR: import("../types.js").RegisteredError;
 export declare const REQUEST_ERROR: import("../types.js").RegisteredError;
 export declare const SERVICE_OVERLOADED: import("../types.js").RegisteredError;
+export declare const PROJECT_EXECUTION_UNAVAILABLE: import("../types.js").RegisteredError;
 export declare const SEMAPHORE_TIMEOUT: import("../types.js").RegisteredError;
 export declare const CIRCUIT_BREAKER_OPEN: import("../types.js").RegisteredError;
 export declare const CACHE_PATH_MISMATCH: import("../types.js").RegisteredError;
@@ -26,6 +27,7 @@ export declare const SERVER_REGISTRY: {
     readonly "file-watch-error": import("../types.js").RegisteredError;
     readonly "request-error": import("../types.js").RegisteredError;
     readonly "service-overloaded": import("../types.js").RegisteredError;
+    readonly "project-execution-unavailable": import("../types.js").RegisteredError;
     readonly "semaphore-timeout": import("../types.js").RegisteredError;
     readonly "circuit-breaker-open": import("../types.js").RegisteredError;
     readonly "cache-path-mismatch": import("../types.js").RegisteredError;

package/esm/src/errors/error-registry/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/server.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,uCAMtB,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,WAAW,uCAMtB,CAAC;AAEH,eAAO,MAAM,gBAAgB,uCAM3B,CAAC;AAEH,eAAO,MAAM,aAAa,uCAMxB,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,eAAO,MAAM,oBAAoB,uCAM/B,CAAC;AAEH,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,eAAO,MAAM,aAAa,uCAMxB,CAAC;AAEH,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,uCAM3B,CAAC;AAEH,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,qEAAqE;AACrE,eAAO,MAAM,yBAAyB,uCAMpC,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,+DAA+D;AAC/D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CAgBlB,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/server.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,uCAMtB,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,WAAW,uCAMtB,CAAC;AAEH,eAAO,MAAM,gBAAgB,uCAM3B,CAAC;AAEH,eAAO,MAAM,aAAa,uCAMxB,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,6BAA6B,uCAMxC,CAAC;AAEH,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,eAAO,MAAM,oBAAoB,uCAM/B,CAAC;AAEH,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,eAAO,MAAM,aAAa,uCAMxB,CAAC;AAEH,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,uCAM3B,CAAC;AAEH,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,qEAAqE;AACrE,eAAO,MAAM,yBAAyB,uCAMpC,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,+DAA+D;AAC/D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAiBlB,CAAC"}

package/esm/src/errors/error-registry/server.js

@@ -41,6 +41,13 @@ export const SERVICE_OVERLOADED = defineError({
     title: "Service overloaded",
     suggestion: "Reduce load or scale up resources",
 });
+export const PROJECT_EXECUTION_UNAVAILABLE = defineError({
+    slug: "project-execution-unavailable",
+    category: "SERVER",
+    status: 503,
+    title: "Project execution unavailable",
+    suggestion: "Route the project to a dedicated isolated runtime",
+});
 export const SEMAPHORE_TIMEOUT = defineError({
     slug: "semaphore-timeout",
     category: "SERVER",
@@ -117,6 +124,7 @@ export const SERVER_REGISTRY = {
     "file-watch-error": FILE_WATCH_ERROR,
     "request-error": REQUEST_ERROR,
     "service-overloaded": SERVICE_OVERLOADED,
+    "project-execution-unavailable": PROJECT_EXECUTION_UNAVAILABLE,
     "semaphore-timeout": SEMAPHORE_TIMEOUT,
     "circuit-breaker-open": CIRCUIT_BREAKER_OPEN,
     "cache-path-mismatch": CACHE_PATH_MISMATCH,

package/esm/src/errors/error-registry-helpers.d.ts

@@ -1,6 +1,15 @@
 import type { ErrorCategory, RegisteredError } from "./types.js";
-export type ErrorRegistryMap = Record<string, RegisteredError>;
-export declare function getRegistryEntry<Registry extends ErrorRegistryMap, Slug extends keyof Registry>(registry: Registry, slug: Slug): Registry[Slug];
+export type ErrorRegistryMap = Readonly<Record<string, RegisteredError>>;
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type ComposedSlugMap<Fragments extends readonly object[]> = UnionToIntersection<Fragments[number]>;
+/**
+ * Compose slug-keyed fragments without object-spread's silent last-write-wins behavior.
+ */
+export declare function composeSluggedMaps<const Fragments extends readonly object[]>(collectionName: string, ...fragments: Fragments): Readonly<ComposedSlugMap<Fragments>>;
+export declare function composeErrorRegistry<const Fragments extends readonly ErrorRegistryMap[]>(...fragments: Fragments): Readonly<ComposedSlugMap<Fragments>>;
+export declare function getRegistryEntry<Registry extends ErrorRegistryMap, Slug extends Extract<keyof Registry, string>>(registry: Registry, slug: Slug): Registry[Slug];
+export declare function getRegistryEntry(registry: ErrorRegistryMap, slug: string): RegisteredError | undefined;
 export declare function getRegistryEntriesByCategory(registry: ErrorRegistryMap, category: ErrorCategory): RegisteredError[];
 export declare function getRegistrySlugs<Registry extends ErrorRegistryMap>(registry: Registry): Array<keyof Registry>;
+export {};
 //# sourceMappingURL=error-registry-helpers.d.ts.map

package/esm/src/errors/error-registry-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-registry-helpers.d.ts","sourceRoot":"","sources":["../../../src/src/errors/error-registry-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AAE/D,wBAAgB,gBAAgB,CAC9B,QAAQ,SAAS,gBAAgB,EACjC,IAAI,SAAS,MAAM,QAAQ,EAC3B,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAEhD;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,aAAa,GACtB,eAAe,EAAE,CAEnB;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,SAAS,gBAAgB,EAChE,QAAQ,EAAE,QAAQ,GACjB,KAAK,CAAC,MAAM,QAAQ,CAAC,CAEvB"}
+{"version":3,"file":"error-registry-helpers.d.ts","sourceRoot":"","sources":["../../../src/src/errors/error-registry-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;AAgBzE,KAAK,mBAAmB,CAAC,KAAK,IAAI,CAChC,KAAK,SAAS,OAAO,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,KAAK,CACvD,SAAS,CAAC,KAAK,EAAE,MAAM,YAAY,KAAK,IAAI,GAAG,YAAY,GAAG,KAAK,CAAC;AAErE,KAAK,eAAe,CAAC,SAAS,SAAS,SAAS,MAAM,EAAE,IAAI,mBAAmB,CAC7E,SAAS,CAAC,MAAM,CAAC,CAClB,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,SAAS,SAAS,SAAS,MAAM,EAAE,EAC1E,cAAc,EAAE,MAAM,EACtB,GAAG,SAAS,EAAE,SAAS,GACtB,QAAQ,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CA6BtC;AAED,wBAAgB,oBAAoB,CAAC,KAAK,CAAC,SAAS,SAAS,SAAS,gBAAgB,EAAE,EACtF,GAAG,SAAS,EAAE,SAAS,GACtB,QAAQ,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAyCtC;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,SAAS,gBAAgB,EACjC,IAAI,SAAS,OAAO,CAAC,MAAM,QAAQ,EAAE,MAAM,CAAC,EAC5C,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;AAClD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,MAAM,GACX,eAAe,GAAG,SAAS,CAAC;AAQ/B,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,aAAa,GACtB,eAAe,EAAE,CAEnB;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,SAAS,gBAAgB,EAChE,QAAQ,EAAE,QAAQ,GACjB,KAAK,CAAC,MAAM,QAAQ,CAAC,CAEvB"}

package/esm/src/errors/error-registry-helpers.js

@@ -1,5 +1,74 @@
+const ERROR_CATEGORIES = new Set([
+    "CONFIG",
+    "BUILD",
+    "RUNTIME",
+    "ROUTE",
+    "MODULE",
+    "SERVER",
+    "BOUNDARY",
+    "DEV",
+    "DEPLOY",
+    "AGENT",
+    "GENERAL",
+]);
+/**
+ * Compose slug-keyed fragments without object-spread's silent last-write-wins behavior.
+ */
+export function composeSluggedMaps(collectionName, ...fragments) {
+    const composed = Object.create(null);
+    const capitalizedCollectionName = collectionName.charAt(0).toUpperCase() +
+        collectionName.slice(1);
+    for (const fragment of fragments) {
+        for (const [key, entry] of Object.entries(fragment)) {
+            if (typeof entry !== "object" || entry === null || !Object.hasOwn(entry, "slug")) {
+                throw new Error(`${capitalizedCollectionName} entry "${key}" must define a slug`);
+            }
+            const slug = entry.slug;
+            if (typeof slug !== "string") {
+                throw new Error(`${capitalizedCollectionName} entry "${key}" must define a string slug`);
+            }
+            if (slug !== key) {
+                throw new Error(`${capitalizedCollectionName} key "${key}" does not match entry slug "${slug}"`);
+            }
+            if (Object.hasOwn(composed, key)) {
+                throw new Error(`Duplicate ${collectionName} slug "${key}"`);
+            }
+            composed[key] = entry;
+        }
+    }
+    return Object.freeze(composed);
+}
+export function composeErrorRegistry(...fragments) {
+    for (const fragment of fragments) {
+        for (const definition of Object.values(fragment)) {
+            if (typeof definition.slug !== "string" ||
+                definition.slug.length < 3 ||
+                definition.slug.length > 40 ||
+                !/^[a-z][a-z0-9-]*[a-z0-9]$/.test(definition.slug)) {
+                throw new TypeError(`Registered error slug must be 3-40 characters of lowercase kebab-case, got "${definition.slug}"`);
+            }
+            if (typeof definition.category !== "string" ||
+                !ERROR_CATEGORIES.has(definition.category)) {
+                throw new TypeError(`Registered error has unknown category "${definition.category}"`);
+            }
+            if (!Number.isInteger(definition.status) || definition.status < 400 ||
+                definition.status >= 600) {
+                throw new RangeError(`Registered error status must be an integer from 400 through 599, got ${definition.status}`);
+            }
+            if (typeof definition.title !== "string" || definition.title.trim().length === 0) {
+                throw new TypeError("Registered error title must be a non-empty string");
+            }
+            if (definition.suggestion !== undefined &&
+                (typeof definition.suggestion !== "string" ||
+                    definition.suggestion.trim().length === 0)) {
+                throw new TypeError("Registered error suggestion must be non-empty when provided");
+            }
+        }
+    }
+    return composeSluggedMaps("error registry", ...fragments);
+}
 export function getRegistryEntry(registry, slug) {
-    return registry[slug];
+    return Object.hasOwn(registry, slug) ? registry[slug] : undefined;
 }
 export function getRegistryEntriesByCategory(registry, category) {
     return Object.values(registry).filter((error) => error.category === category);

package/esm/src/errors/error-registry.d.ts

@@ -3,18 +3,18 @@ export * from "./error-registry/config.js";
 export * from "./error-registry/build.js";
 export * from "./error-registry/runtime.js";
 export * from "./error-registry/route.js";
-export * from "./error-registry/module.js";
+export * from "veryfront/errors/module";
 export * from "./error-registry/server.js";
 export * from "./error-registry/boundary.js";
 export * from "./error-registry/dev.js";
 export * from "./error-registry/deploy.js";
 export * from "./error-registry/agent.js";
-export * from "./error-registry/general.js";
+export * from "veryfront/errors/general";
 /**
  * Central registry mapping every error slug to its definition. Assembled from
  * the per-category registry fragments.
  */
-export declare const ERROR_REGISTRY: {
+export declare const ERROR_REGISTRY: Readonly<{
     readonly "unknown-error": import("./types.js").RegisteredError;
     readonly "authentication-required": import("./types.js").RegisteredError;
     readonly "permission-denied": import("./types.js").RegisteredError;
@@ -27,42 +27,60 @@ export declare const ERROR_REGISTRY: {
     readonly "security-violation": import("./types.js").RegisteredError;
     readonly "input-validation-failed": import("./types.js").RegisteredError;
     readonly "project-source-empty": import("./types.js").RegisteredError;
-    readonly "agent-error": import("./types.js").RegisteredError;
-    readonly "agent-not-found": import("./types.js").RegisteredError;
-    readonly "agent-timeout": import("./types.js").RegisteredError;
-    readonly "agent-intent-error": import("./types.js").RegisteredError;
-    readonly "orchestration-error": import("./types.js").RegisteredError;
-    readonly "cost-limit-exceeded": import("./types.js").RegisteredError;
-    readonly "tool-id-conflict": import("./types.js").RegisteredError;
-    readonly "deployment-error": import("./types.js").RegisteredError;
-    readonly "platform-error": import("./types.js").RegisteredError;
-    readonly "env-var-missing": import("./types.js").RegisteredError;
-    readonly "production-build-required": import("./types.js").RegisteredError;
-    readonly "environment-not-found": import("./types.js").RegisteredError;
-    readonly "release-missing-version": import("./types.js").RegisteredError;
-    readonly "release-build-timeout": import("./types.js").RegisteredError;
-    readonly "deployment-verification-timeout": import("./types.js").RegisteredError;
-    readonly "push-receipt-missing": import("./types.js").RegisteredError;
-    readonly "source-digest-mismatch": import("./types.js").RegisteredError;
-    readonly "preview-hostname-too-long": import("./types.js").RegisteredError;
-    readonly "branch-not-found": import("./types.js").RegisteredError;
-    readonly "hmr-error": import("./types.js").RegisteredError;
-    readonly "dev-server-error": import("./types.js").RegisteredError;
-    readonly "fast-refresh-error": import("./types.js").RegisteredError;
-    readonly "error-overlay-error": import("./types.js").RegisteredError;
-    readonly "source-map-error": import("./types.js").RegisteredError;
-    readonly "client-boundary-violation": import("./types.js").RegisteredError;
-    readonly "server-only-in-client": import("./types.js").RegisteredError;
-    readonly "client-only-in-server": import("./types.js").RegisteredError;
-    readonly "invalid-use-client": import("./types.js").RegisteredError;
-    readonly "invalid-use-server": import("./types.js").RegisteredError;
-    readonly "rsc-payload-error": import("./types.js").RegisteredError;
+} & {
+    readonly "config-not-found": import("./types.js").RegisteredError;
+    readonly "config-invalid": import("./types.js").RegisteredError;
+    readonly "config-parse-error": import("./types.js").RegisteredError;
+    readonly "config-validation-error": import("./types.js").RegisteredError;
+    readonly "config-type-error": import("./types.js").RegisteredError;
+    readonly "import-map-invalid": import("./types.js").RegisteredError;
+    readonly "cors-config-invalid": import("./types.js").RegisteredError;
+    readonly "config-validation-failed": import("./types.js").RegisteredError;
+    readonly "webhook-config-invalid": import("./types.js").RegisteredError;
+    readonly "schedule-config-invalid": import("./types.js").RegisteredError;
+    readonly "trigger-config-invalid": import("./types.js").RegisteredError;
+} & {
+    readonly "build-failed": import("./types.js").RegisteredError;
+    readonly "bundle-error": import("./types.js").RegisteredError;
+    readonly "typescript-error": import("./types.js").RegisteredError;
+    readonly "mdx-compile-error": import("./types.js").RegisteredError;
+    readonly "asset-optimization-error": import("./types.js").RegisteredError;
+    readonly "ssg-generation-error": import("./types.js").RegisteredError;
+    readonly "sourcemap-error": import("./types.js").RegisteredError;
+    readonly "compilation-error": import("./types.js").RegisteredError;
+} & {
+    readonly "hydration-mismatch": import("./types.js").RegisteredError;
+    readonly "render-error": import("./types.js").RegisteredError;
+    readonly "component-error": import("./types.js").RegisteredError;
+    readonly "layout-not-found": import("./types.js").RegisteredError;
+    readonly "page-not-found": import("./types.js").RegisteredError;
+    readonly "api-error": import("./types.js").RegisteredError;
+    readonly "middleware-error": import("./types.js").RegisteredError;
+    readonly "trigger-target-not-found": import("./types.js").RegisteredError;
+    readonly "trigger-execution-failed": import("./types.js").RegisteredError;
+    readonly "trigger-not-supported": import("./types.js").RegisteredError;
+} & {
+    readonly "route-conflict": import("./types.js").RegisteredError;
+    readonly "invalid-route-file": import("./types.js").RegisteredError;
+    readonly "route-handler-invalid": import("./types.js").RegisteredError;
+    readonly "dynamic-route-error": import("./types.js").RegisteredError;
+    readonly "route-params-error": import("./types.js").RegisteredError;
+    readonly "api-route-error": import("./types.js").RegisteredError;
+} & {
+    readonly "module-not-found": import("./types.js").RegisteredError;
+    readonly "import-resolution-error": import("./types.js").RegisteredError;
+    readonly "circular-dependency": import("./types.js").RegisteredError;
+    readonly "invalid-import": import("./types.js").RegisteredError;
+    readonly "dependency-missing": import("./types.js").RegisteredError;
+    readonly "version-mismatch": import("./types.js").RegisteredError;
+} & {
     readonly "port-in-use": import("./types.js").RegisteredError;
     readonly "server-start-error": import("./types.js").RegisteredError;
     readonly "cache-error": import("./types.js").RegisteredError;
     readonly "file-watch-error": import("./types.js").RegisteredError;
     readonly "request-error": import("./types.js").RegisteredError;
     readonly "service-overloaded": import("./types.js").RegisteredError;
+    readonly "project-execution-unavailable": import("./types.js").RegisteredError;
     readonly "semaphore-timeout": import("./types.js").RegisteredError;
     readonly "circuit-breaker-open": import("./types.js").RegisteredError;
     readonly "cache-path-mismatch": import("./types.js").RegisteredError;
@@ -72,48 +90,42 @@ export declare const ERROR_REGISTRY: {
     readonly "cache-invariant-violation": import("./types.js").RegisteredError;
     readonly "release-not-found": import("./types.js").RegisteredError;
     readonly "fallback-exhausted": import("./types.js").RegisteredError;
-    readonly "module-not-found": import("./types.js").RegisteredError;
-    readonly "import-resolution-error": import("./types.js").RegisteredError;
-    readonly "circular-dependency": import("./types.js").RegisteredError;
-    readonly "invalid-import": import("./types.js").RegisteredError;
-    readonly "dependency-missing": import("./types.js").RegisteredError;
-    readonly "version-mismatch": import("./types.js").RegisteredError;
-    readonly "route-conflict": import("./types.js").RegisteredError;
-    readonly "invalid-route-file": import("./types.js").RegisteredError;
-    readonly "route-handler-invalid": import("./types.js").RegisteredError;
-    readonly "dynamic-route-error": import("./types.js").RegisteredError;
-    readonly "route-params-error": import("./types.js").RegisteredError;
-    readonly "api-route-error": import("./types.js").RegisteredError;
-    readonly "hydration-mismatch": import("./types.js").RegisteredError;
-    readonly "render-error": import("./types.js").RegisteredError;
-    readonly "component-error": import("./types.js").RegisteredError;
-    readonly "layout-not-found": import("./types.js").RegisteredError;
-    readonly "page-not-found": import("./types.js").RegisteredError;
-    readonly "api-error": import("./types.js").RegisteredError;
-    readonly "middleware-error": import("./types.js").RegisteredError;
-    readonly "trigger-target-not-found": import("./types.js").RegisteredError;
-    readonly "trigger-execution-failed": import("./types.js").RegisteredError;
-    readonly "trigger-not-supported": import("./types.js").RegisteredError;
-    readonly "build-failed": import("./types.js").RegisteredError;
-    readonly "bundle-error": import("./types.js").RegisteredError;
-    readonly "typescript-error": import("./types.js").RegisteredError;
-    readonly "mdx-compile-error": import("./types.js").RegisteredError;
-    readonly "asset-optimization-error": import("./types.js").RegisteredError;
-    readonly "ssg-generation-error": import("./types.js").RegisteredError;
-    readonly "sourcemap-error": import("./types.js").RegisteredError;
-    readonly "compilation-error": import("./types.js").RegisteredError;
-    readonly "config-not-found": import("./types.js").RegisteredError;
-    readonly "config-invalid": import("./types.js").RegisteredError;
-    readonly "config-parse-error": import("./types.js").RegisteredError;
-    readonly "config-validation-error": import("./types.js").RegisteredError;
-    readonly "config-type-error": import("./types.js").RegisteredError;
-    readonly "import-map-invalid": import("./types.js").RegisteredError;
-    readonly "cors-config-invalid": import("./types.js").RegisteredError;
-    readonly "config-validation-failed": import("./types.js").RegisteredError;
-    readonly "webhook-config-invalid": import("./types.js").RegisteredError;
-    readonly "schedule-config-invalid": import("./types.js").RegisteredError;
-    readonly "trigger-config-invalid": import("./types.js").RegisteredError;
-};
+} & {
+    readonly "client-boundary-violation": import("./types.js").RegisteredError;
+    readonly "server-only-in-client": import("./types.js").RegisteredError;
+    readonly "client-only-in-server": import("./types.js").RegisteredError;
+    readonly "invalid-use-client": import("./types.js").RegisteredError;
+    readonly "invalid-use-server": import("./types.js").RegisteredError;
+    readonly "rsc-payload-error": import("./types.js").RegisteredError;
+    readonly "ssr-output-limit-exceeded": import("./types.js").RegisteredError;
+} & {
+    readonly "hmr-error": import("./types.js").RegisteredError;
+    readonly "dev-server-error": import("./types.js").RegisteredError;
+    readonly "fast-refresh-error": import("./types.js").RegisteredError;
+    readonly "error-overlay-error": import("./types.js").RegisteredError;
+    readonly "source-map-error": import("./types.js").RegisteredError;
+} & {
+    readonly "deployment-error": import("./types.js").RegisteredError;
+    readonly "platform-error": import("./types.js").RegisteredError;
+    readonly "env-var-missing": import("./types.js").RegisteredError;
+    readonly "production-build-required": import("./types.js").RegisteredError;
+    readonly "environment-not-found": import("./types.js").RegisteredError;
+    readonly "release-missing-version": import("./types.js").RegisteredError;
+    readonly "release-build-timeout": import("./types.js").RegisteredError;
+    readonly "deployment-verification-timeout": import("./types.js").RegisteredError;
+    readonly "push-receipt-missing": import("./types.js").RegisteredError;
+    readonly "source-digest-mismatch": import("./types.js").RegisteredError;
+    readonly "preview-hostname-too-long": import("./types.js").RegisteredError;
+    readonly "branch-not-found": import("./types.js").RegisteredError;
+} & {
+    readonly "agent-error": import("./types.js").RegisteredError;
+    readonly "agent-not-found": import("./types.js").RegisteredError;
+    readonly "agent-timeout": import("./types.js").RegisteredError;
+    readonly "agent-intent-error": import("./types.js").RegisteredError;
+    readonly "orchestration-error": import("./types.js").RegisteredError;
+    readonly "cost-limit-exceeded": import("./types.js").RegisteredError;
+    readonly "tool-id-conflict": import("./types.js").RegisteredError;
+}>;
 export type ErrorSlug = keyof typeof ERROR_REGISTRY;
 /**
  * Get an error definition by slug

package/esm/src/errors/error-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-registry.d.ts","sourceRoot":"","sources":["../../../src/src/errors/error-registry.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAgBhD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYjB,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,cAAc,CAAC;AAEpD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,wCAE7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,0CAE1D;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,SAAS,EAAE,CAEzC"}
+{"version":3,"file":"error-registry.d.ts","sourceRoot":"","sources":["../../../src/src/errors/error-registry.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAgBhD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY1B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,cAAc,CAAC;AAEpD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,wCAE7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,0CAE1D;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,SAAS,EAAE,CAEzC"}

package/esm/src/errors/error-registry.js

@@ -1,4 +1,4 @@
-import { getRegistryEntriesByCategory, getRegistryEntry, getRegistrySlugs, } from "./error-registry-helpers.js";
+import { composeErrorRegistry, getRegistryEntriesByCategory, getRegistryEntry, getRegistrySlugs, } from "./error-registry-helpers.js";
 // Error definitions live in per-category modules under ./error-registry/.
 // This barrel re-exports them and assembles the slug → definition registry.
 import { CONFIG_REGISTRY } from "./error-registry/config.js";
@@ -27,19 +27,7 @@ export * from "./error-registry/general.js";
  * Central registry mapping every error slug to its definition. Assembled from
  * the per-category registry fragments.
  */
-export const ERROR_REGISTRY = {
-    ...CONFIG_REGISTRY,
-    ...BUILD_REGISTRY,
-    ...RUNTIME_REGISTRY,
-    ...ROUTE_REGISTRY,
-    ...MODULE_REGISTRY,
-    ...SERVER_REGISTRY,
-    ...BOUNDARY_REGISTRY,
-    ...DEV_REGISTRY,
-    ...DEPLOY_REGISTRY,
-    ...AGENT_REGISTRY,
-    ...GENERAL_REGISTRY,
-};
+export const ERROR_REGISTRY = composeErrorRegistry(CONFIG_REGISTRY, BUILD_REGISTRY, RUNTIME_REGISTRY, ROUTE_REGISTRY, MODULE_REGISTRY, SERVER_REGISTRY, BOUNDARY_REGISTRY, DEV_REGISTRY, DEPLOY_REGISTRY, AGENT_REGISTRY, GENERAL_REGISTRY);
 /**
  * Get an error definition by slug
  */