@lupinum/ginko-content 0.1.0

package/dist/core/query/operators.js

@@ -0,0 +1,126 @@
+const isNullish = (value) => value === null || value === void 0;
+export const get = (obj, path) => path.split(".").reduce((acc, part) => acc && typeof acc === "object" ? acc[part] : void 0, obj);
+const pickObject = (obj, condition) => Object.keys(obj).filter(condition).reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {});
+export const omit = (keys) => (obj) => keys && keys.length ? pickObject(obj, (key) => !keys.includes(key)) : obj;
+export const apply = (fn) => (data) => Array.isArray(data) ? data.map((item) => fn(item)) : fn(data);
+export const detectProperties = (keys) => {
+  const prefixes = [];
+  const properties = [];
+  for (const key of keys) {
+    if (["$", "_"].includes(key)) {
+      prefixes.push(key);
+    } else {
+      properties.push(key);
+    }
+  }
+  return { prefixes, properties };
+};
+export const withoutKeys = (keys = []) => (obj) => {
+  if (keys.length === 0 || !obj) {
+    return obj;
+  }
+  const { prefixes, properties } = detectProperties(keys);
+  return pickObject(obj, (key) => !properties.includes(key) && !prefixes.includes(key.charAt(0)));
+};
+export const withKeys = (keys = []) => (obj) => {
+  if (keys.length === 0 || !obj) {
+    return obj;
+  }
+  const { prefixes, properties } = detectProperties(keys);
+  return pickObject(obj, (key) => properties.includes(key) || prefixes.includes(key.charAt(0)));
+};
+export const sortList = (data, params) => {
+  const sortParams = params;
+  const comperable = new Intl.Collator(sortParams.$locale, {
+    numeric: sortParams.$numeric,
+    caseFirst: sortParams.$caseFirst,
+    sensitivity: sortParams.$sensitivity
+  });
+  const keys = Object.keys(params).filter((key) => !key.startsWith("$"));
+  for (const key of keys) {
+    data = data.sort((a, b) => {
+      const values = [get(a, key), get(b, key)].map((value) => {
+        if (value === null) {
+          return void 0;
+        }
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        return typeof value === "undefined" ? void 0 : String(value);
+      });
+      if (params[key] === -1) {
+        values.reverse();
+      }
+      return comperable.compare(values[0] || "", values[1] || "");
+    });
+  }
+  return data;
+};
+export function assertArray(value, message = "Expected an array") {
+  if (!Array.isArray(value)) {
+    throw new TypeError(message);
+  }
+}
+export const ensureArray = (value) => {
+  return Array.isArray(value) ? value : isNullish(value) ? [] : [value];
+};
+const LOGICAL_QUERY_OPERATORS = /* @__PURE__ */ new Set(["$and", "$or", "$not"]);
+export const SUPPORTED_QUERY_OPERATORS = [
+  "$eq",
+  "$ne",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$contains",
+  "$containsAny",
+  "$icontains",
+  "$exists",
+  "$type",
+  "$regex",
+  "$prefix",
+  "$options",
+  "$not"
+];
+const isQueryOperatorRecord = (value) => {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && !(value instanceof RegExp) && !(value instanceof Date);
+};
+export const containsStandaloneRegexOptions = (value) => {
+  if (!isQueryOperatorRecord(value)) {
+    return false;
+  }
+  if ("$options" in value && !("$regex" in value)) {
+    return true;
+  }
+  return Object.values(value).some((child) => {
+    if (Array.isArray(child)) {
+      return child.some(containsStandaloneRegexOptions);
+    }
+    return containsStandaloneRegexOptions(child);
+  });
+};
+export const findUnsupportedQueryOperator = (value, extraOperators = []) => {
+  if (!value || value instanceof RegExp || value instanceof Date) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => findUnsupportedQueryOperator(item, extraOperators)).find(Boolean);
+  }
+  if (!isQueryOperatorRecord(value)) {
+    return void 0;
+  }
+  for (const [key, nested] of Object.entries(value)) {
+    if (key.startsWith("$") && !LOGICAL_QUERY_OPERATORS.has(key) && !SUPPORTED_QUERY_OPERATORS.includes(key) && !extraOperators.includes(key)) {
+      return key;
+    }
+    const unsupported = findUnsupportedQueryOperator(nested, extraOperators);
+    if (unsupported) return unsupported;
+  }
+};
+export const assertSupportedQueryOperators = (value, extraOperators = []) => {
+  const unsupported = findUnsupportedQueryOperator(value, extraOperators);
+  if (unsupported) {
+    throw new TypeError(`Unsupported content query operator: ${unsupported}`);
+  }
+};

package/dist/core/query/params

@@ -0,0 +1 @@
+export * from './params.js'

package/dist/core/query/params.d.ts

@@ -0,0 +1,15 @@
+import type { ContentQueryBuilderParams, ContentQueryBuilderWhere } from '../../types/query';
+import type { ContentCollectionI18nConfig } from '../../types/config';
+export declare const encodeQueryParams: (params: ContentQueryBuilderParams) => string;
+export declare const decodeQueryParams: (encoded: string) => any;
+export declare const ensureQueryWhereArray: (where?: ContentQueryBuilderParams["where"]) => ContentQueryBuilderWhere[];
+export declare const collectQueryWhere: (where: ContentQueryBuilderParams["where"], predicate: (condition: ContentQueryBuilderWhere) => boolean) => ContentQueryBuilderWhere[];
+export declare const findQueryWhere: (where: ContentQueryBuilderParams["where"], predicate: (condition: ContentQueryBuilderWhere) => boolean) => ContentQueryBuilderWhere | undefined;
+export declare const normalizeContentQueryParams: (params: ContentQueryBuilderParams, options?: {
+    path?: string;
+    collectionI18n?: ContentCollectionI18nConfig;
+    defaultLocale?: string;
+    localeFallback?: Record<string, string[]>;
+    activeLocale?: string;
+    includeDraftFilter?: boolean;
+}) => ContentQueryBuilderParams;

package/dist/core/query/params.js

@@ -0,0 +1,83 @@
+import { buildLocaleFallbackChain } from "../content/locale.js";
+import { jsonParse, jsonStringify } from "./json.js";
+import { withoutTrailingSlash } from "ufo";
+export const encodeQueryParams = (params) => {
+  let encoded = jsonStringify(params);
+  encoded = typeof Buffer !== "undefined" ? Buffer.from(encoded).toString("base64") : btoa(encoded);
+  encoded = encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  const chunks = encoded.match(/.{1,100}/g) || [];
+  return chunks.join("/");
+};
+export const decodeQueryParams = (encoded) => {
+  encoded = encoded.replace(/\//g, "");
+  encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  encoded = encoded.padEnd(encoded.length + (4 - encoded.length % 4) % 4, "=");
+  return jsonParse(typeof Buffer !== "undefined" ? Buffer.from(encoded, "base64").toString() : atob(encoded));
+};
+const escapeContentPath = (path) => path.replace(/[-[\]{}()*+.,^$\s/]/g, "\\$&");
+export const ensureQueryWhereArray = (where) => {
+  return Array.isArray(where) ? [...where] : where ? [where] : [];
+};
+export const collectQueryWhere = (where, predicate) => {
+  const matches = [];
+  const visit = (conditions) => {
+    for (const condition of ensureQueryWhereArray(conditions)) {
+      if (predicate(condition)) {
+        matches.push(condition);
+      }
+      if (condition.$and) {
+        visit(condition.$and);
+      }
+      if (condition.$or) {
+        visit(condition.$or);
+      }
+      if (condition.$not && typeof condition.$not === "object" && !Array.isArray(condition.$not) && !(condition.$not instanceof RegExp)) {
+        visit(condition.$not);
+      }
+    }
+  };
+  visit(where);
+  return matches;
+};
+export const findQueryWhere = (where, predicate) => collectQueryWhere(where, predicate)[0];
+export const normalizeContentQueryParams = (params, options = {}) => {
+  const where = ensureQueryWhereArray(params.where);
+  const normalized = {
+    ...params,
+    where,
+    sort: params.sort ? [...params.sort] : params.sort
+  };
+  if (options.path) {
+    if (normalized.first && where.length === 0) {
+      where.push({ _path: withoutTrailingSlash(options.path) });
+    } else {
+      where.push({ _path: new RegExp(`^${escapeContentPath(options.path)}`) });
+    }
+  }
+  if (!normalized.sort?.length) {
+    normalized.sort = [{ _stem: 1, $numeric: true }];
+  }
+  if (normalized.resolveLocale?.locale && normalized.resolveLocale.fallback === true) {
+    normalized.resolveLocale = {
+      ...normalized.resolveLocale,
+      fallback: buildLocaleFallbackChain(
+        normalized.resolveLocale.locale,
+        options.collectionI18n?.defaultLocale || options.defaultLocale,
+        options.localeFallback
+      )
+    };
+  }
+  if (options.includeDraftFilter) {
+    if (!findQueryWhere(where, (item) => typeof item._draft !== "undefined")) {
+      where.push({ _draft: { $ne: true } });
+    }
+  }
+  if (options.collectionI18n?.locales.length && !normalized.resolveLocale && !normalized.resolveVariant) {
+    const queryLocale = findQueryWhere(where, (item) => typeof item._locale !== "undefined")?._locale;
+    const defaultLocale = options.activeLocale || options.collectionI18n.defaultLocale;
+    if (!queryLocale && defaultLocale) {
+      where.push({ _locale: defaultLocale });
+    }
+  }
+  return normalized;
+};

package/dist/core/query/plan

@@ -0,0 +1 @@
+export * from './plan.js'

package/dist/core/query/plan.d.ts

@@ -0,0 +1,110 @@
+/**
+ * The internal, **immutable**, executor-facing query AST.
+ *
+ * Pipeline: public `ContentQueryBuilder` → `params` object → `lowerQueryPlan`
+ * (see `./lower.ts`) → `ContentQueryPlan` → `executeQueryPlan`
+ * (see `./execute.ts`).
+ *
+ * The plan is the stable boundary between "how the user wrote the query"
+ * and "how we execute it." Downstream code should pattern-match on
+ * `FilterExpr.type` rather than reading builder params directly. The plan
+ * never carries Nuxt/H3/Vue concerns.
+ *
+ * The plan stays immutable so builders, lowerers, and executors can compose
+ * without hidden shared state.
+ */
+/** Discriminator for a `{ type: 'compare' }` filter node. */
+export type CompareOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'containsAny' | 'icontains' | 'exists' | 'type' | 'regex' | 'prefix';
+/**
+ * Normalized where-clause AST. `{ type: 'true' }` is the identity node used
+ * when the user did not pass any predicate; this keeps downstream code free
+ * of `if (!filter)` branches.
+ */
+export type FilterExpr = {
+    type: 'true';
+} | {
+    type: 'compare';
+    field: string;
+    operator: CompareOperator;
+    value?: unknown;
+} | {
+    type: 'and';
+    clauses: FilterExpr[];
+} | {
+    type: 'or';
+    clauses: FilterExpr[];
+} | {
+    type: 'not';
+    clause: FilterExpr;
+};
+/**
+ * One sort term. Clauses are applied in order — earlier fields dominate;
+ * later fields act as tiebreakers.
+ */
+export interface SortClause {
+    field: string;
+    direction: -1 | 1;
+    locale?: string;
+    numeric?: boolean;
+    caseFirst?: 'upper' | 'lower' | 'false';
+    sensitivity?: 'base' | 'accent' | 'case' | 'variant';
+}
+/** Projection is applied after filter/sort but before mode. `only` wins over `without` if both are set. */
+export interface Projection {
+    only: string[];
+    without: string[];
+}
+/** Terminal shape of the query. Set by `.all()`, `.first()`, or `.count()` on the builder. */
+export type QueryMode = 'all' | 'first' | 'count';
+/**
+ * Locale resolution parameters. Populated when a caller uses `.locale(...)`
+ * on the builder or when the adapter injects the active request locale.
+ * When set, the executor dedupes variants across the fallback chain rather
+ * than returning every variant.
+ */
+export interface LocaleResolution {
+    locale?: string;
+    fallback?: string[];
+    exact?: boolean;
+}
+/**
+ * Variant resolution for route-backed page lookup. Used by unified `one(...)`
+ * route selectors and internal route helpers to resolve a localized route path, then fall
+ * back through the locale chain if the requested locale is missing.
+ */
+export interface VariantResolution {
+    /**
+     * Localized or canonical route path to look up via `byRoute` + locale chain.
+     * Mutually exclusive with `route` and `ref`.
+     */
+    path?: string;
+    /**
+     * Public app route to resolve through collection route mounts before looking
+     * up the locale variant. Mutually exclusive with `path` and `ref`.
+     */
+    route?: string;
+    /**
+     * Stable authored alias resolved through `byRef`/`referenceTargets` to a
+     * canonical key, then to the locale-correct variant. Mutually exclusive
+     * with `path` and `route`.
+     */
+    ref?: string;
+    locale?: string;
+    fallback?: string[];
+    exact?: boolean;
+}
+/**
+ * Complete executor-facing plan. Construct via `lowerQueryPlan(params)`;
+ * execute via `executeQueryPlan(graph, plan, options)`. Do not mutate.
+ */
+export interface ContentQueryPlan {
+    collection?: string;
+    filter: FilterExpr;
+    sort: SortClause[];
+    projection: Projection;
+    skip: number;
+    limit?: number;
+    mode: QueryMode;
+    resolveLocale?: LocaleResolution;
+    resolveVariant?: VariantResolution;
+}

package/dist/core/references/resolve

@@ -0,0 +1 @@
+export * from './resolve.js'

package/dist/core/references/resolve.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Reference resolution — turning a user-written identifier into a concrete
+ * document in the graph.
+ *
+ * Three vocabularies the user might reach for:
+ *
+ *  - **Canonical key** — the locale-independent identity baked into the
+ *    document at parse time (e.g. `guide/intro`). This is the authoritative
+ *    form; everything else resolves *to* a canonical key.
+ *  - **Ref** — an explicit `ref:` front-matter field. Authors use this
+ *    when they want a stable short name unchained from file layout.
+ *  - **Path-ish** — a locale-prefixed path (`de/leitfaden/einstieg`), a
+ *    short slug, or a variant filename. `buildReferenceTargets` precomputes
+ *    the full map of these shapes → canonical key so resolution is O(1).
+ *
+ * Contract: `resolveGraphCanonicalKey(graph, identity)` tries each
+ * vocabulary in order and returns `null` if nothing matches. Callers can
+ * trust that a returned canonical key exists in `graph.byCanonical`.
+ */
+import type { ParsedContent } from '../../types/content';
+/** Prefix recognized by `parseRefLink` for inline `$guide/intro` links in markdown. */
+export declare const CONTENT_REF_LINK_PREFIX = "$";
+/** Strip leading/trailing slashes so `/guide/intro/` and `guide/intro` hash to the same canonical form. */
+export declare const normalizeReferenceValue: (value: string) => string;
+export declare const parseRefLink: (value: string) => {
+    ref: string;
+    hash: string;
+} | null;
+export declare const collectMarkdownRefLinks: (node: unknown) => string[];
+export declare const rewriteMarkdownRefLinks: <T>(node: T, resolvedRefs?: Record<string, string>) => T;
+export declare const buildReferenceTargets: (contents: ParsedContent[], locales?: string[]) => Map<string, string>;

package/dist/core/references/resolve.js

@@ -0,0 +1,121 @@
+import { isMarkdownRoot, mapMarkdownNode } from "../markdown/tree.js";
+export const CONTENT_REF_LINK_PREFIX = "$";
+export const normalizeReferenceValue = (value) => String(value).replace(/^\/+|\/+$/g, "");
+export const parseRefLink = (value) => {
+  if (typeof value !== "string" || !value.startsWith(CONTENT_REF_LINK_PREFIX)) {
+    return null;
+  }
+  const [rawRef, ...hashParts] = value.slice(CONTENT_REF_LINK_PREFIX.length).split("#");
+  const ref = normalizeReferenceValue(rawRef || "");
+  if (!ref) {
+    return null;
+  }
+  return {
+    ref,
+    hash: hashParts.length ? `#${hashParts.join("#")}` : ""
+  };
+};
+export const collectMarkdownRefLinks = (node) => {
+  const refs = /* @__PURE__ */ new Set();
+  const visit = (current) => {
+    if (!current || typeof current !== "object") {
+      return;
+    }
+    if (isMarkdownRoot(current)) {
+      current.children.forEach(visit);
+      return;
+    }
+    if (current.type === "element") {
+      const markdownNode = current;
+      const href2 = markdownNode.tag === "a" && typeof markdownNode.props?.href === "string" ? markdownNode.props.href : void 0;
+      if (href2 && parseRefLink(href2)) {
+        refs.add(href2);
+      }
+      markdownNode.children?.forEach(visit);
+      return;
+    }
+    if (Array.isArray(current)) {
+      current.forEach(visit);
+      return;
+    }
+    const href = typeof current.props?.href === "string" && current.tag === "a" ? current.props.href : void 0;
+    if (href && parseRefLink(href)) {
+      refs.add(href);
+    }
+    visit(current.children);
+  };
+  visit(node);
+  return Array.from(refs);
+};
+export const rewriteMarkdownRefLinks = (node, resolvedRefs = {}) => {
+  const visit = (current) => {
+    if (!current || typeof current !== "object") {
+      return current;
+    }
+    if (isMarkdownRoot(current)) {
+      return {
+        ...current,
+        children: current.children.map((item) => visit(item))
+      };
+    }
+    if (current.type === "element") {
+      return mapMarkdownNode(current, (markdownNode) => {
+        const href2 = typeof markdownNode.props?.href === "string" && markdownNode.tag === "a" ? markdownNode.props.href : void 0;
+        if (!href2 || !resolvedRefs[href2]) {
+          return markdownNode;
+        }
+        return {
+          ...markdownNode,
+          props: {
+            ...markdownNode.props,
+            href: resolvedRefs[href2]
+          }
+        };
+      });
+    }
+    if (Array.isArray(current)) {
+      return current.map((item) => visit(item));
+    }
+    const next = { ...current };
+    const href = typeof next.props?.href === "string" && next.tag === "a" ? next.props.href : void 0;
+    if (href && resolvedRefs[href]) {
+      next.props = {
+        ...next.props,
+        href: resolvedRefs[href]
+      };
+    }
+    if (Array.isArray(next.children)) {
+      next.children = next.children.map((child) => visit(child));
+    }
+    return next;
+  };
+  return visit(node);
+};
+export const buildReferenceTargets = (contents, locales = []) => {
+  const targets = /* @__PURE__ */ new Map();
+  for (const document of contents) {
+    if (!document || document._partial || document._navigation) {
+      continue;
+    }
+    const fileParts = (document._file || "").replace(/^\/+/, "").split("/").filter(Boolean);
+    const canonicalId = typeof document._canonicalKey === "string" && document._canonicalKey.length ? document._canonicalKey : fileParts.slice(fileParts[0] && locales.includes(fileParts[0]) ? 1 : 0).join("/").replace(/\.[^.]+$/, "");
+    if (!canonicalId) {
+      continue;
+    }
+    targets.set(canonicalId, canonicalId);
+    if (typeof document.id === "string" && document.id.length) {
+      targets.set(document.id, canonicalId);
+    }
+    if (typeof document.ref === "string" && document.ref.length) {
+      targets.set(document.ref, canonicalId);
+    }
+    const normalizedPath = normalizeReferenceValue(String(document._path || ""));
+    if (normalizedPath) {
+      targets.set(normalizedPath, canonicalId);
+    }
+    if (document._locale && normalizedPath) {
+      targets.set(`${document._locale}/${normalizedPath}`, canonicalId);
+    }
+  }
+  return targets;
+};

package/dist/core/references/schema

@@ -0,0 +1 @@
+export * from './schema.js'

package/dist/core/references/schema.d.ts

@@ -0,0 +1,8 @@
+export declare const getSchemaDef: (schema: any) => any;
+export declare const getSchemaTypeName: (schema: any) => any;
+export declare const unwrapSchema: (schema: any) => any;
+export declare const getObjectShape: (schema: any) => Record<string, any>;
+export declare const getReferenceDescriptor: (schema: any) => {
+    collection?: string;
+} | null;
+export declare const collectTopLevelReferenceFields: (schema: unknown, targetCollection?: string) => string[];

package/dist/core/references/schema.js

@@ -0,0 +1,70 @@
+import { CONTENT_REFERENCE_PREFIX } from "../../types/reference";
+const zodTypeNames = {
+  array: "ZodArray",
+  branded: "ZodBranded",
+  catch: "ZodCatch",
+  default: "ZodDefault",
+  boolean: "ZodBoolean",
+  date: "ZodDate",
+  enum: "ZodEnum",
+  nullable: "ZodNullable",
+  number: "ZodNumber",
+  object: "ZodObject",
+  optional: "ZodOptional",
+  pipe: "ZodEffects",
+  string: "ZodString",
+  transform: "ZodEffects"
+};
+export const getSchemaDef = (schema) => schema?._def || schema?.def;
+export const getSchemaTypeName = (schema) => {
+  const def = getSchemaDef(schema);
+  return def?.typeName || zodTypeNames[def?.type] || def?.type;
+};
+export const unwrapSchema = (schema) => {
+  let current = schema;
+  while (["ZodOptional", "ZodNullable", "ZodDefault", "ZodEffects", "ZodBranded", "ZodCatch"].includes(getSchemaTypeName(current))) {
+    const def = getSchemaDef(current);
+    current = def.innerType || def.schema || def.in || def.out || def.type;
+  }
+  return current;
+};
+export const getObjectShape = (schema) => {
+  const shape = getSchemaDef(schema)?.shape;
+  return typeof shape === "function" ? shape() : shape || schema?.shape || {};
+};
+export const getReferenceDescriptor = (schema) => {
+  const base = unwrapSchema(schema);
+  if (getSchemaTypeName(base) !== "ZodString") {
+    return null;
+  }
+  const description = typeof base.description === "string" ? base.description : "";
+  if (!description.startsWith(CONTENT_REFERENCE_PREFIX)) {
+    return null;
+  }
+  return {
+    collection: description.slice(CONTENT_REFERENCE_PREFIX.length) || void 0
+  };
+};
+const getArrayElement = (schema) => {
+  const current = unwrapSchema(schema);
+  if (getSchemaTypeName(current) !== "ZodArray") {
+    return null;
+  }
+  const def = getSchemaDef(current);
+  return def.element || def.type || null;
+};
+export const collectTopLevelReferenceFields = (schema, targetCollection) => {
+  const current = unwrapSchema(schema);
+  if (getSchemaTypeName(current) !== "ZodObject") {
+    return [];
+  }
+  return Object.entries(getObjectShape(current)).filter(([, childSchema]) => {
+    const direct = getReferenceDescriptor(childSchema);
+    if (direct) {
+      return !direct.collection || !targetCollection || direct.collection === targetCollection;
+    }
+    const arrayElement = getArrayElement(childSchema);
+    const arrayRef = arrayElement ? getReferenceDescriptor(arrayElement) : null;
+    return Boolean(arrayRef && (!arrayRef.collection || !targetCollection || arrayRef.collection === targetCollection));
+  }).map(([field]) => field);
+};

package/dist/core/result

@@ -0,0 +1 @@
+export * from './result.js'

package/dist/core/result.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A discriminated-union result type used at **internal** boundaries where
+ * failure is expected (duplicate canonical IDs, invalid front-matter,
+ * conflicting refs). Programmer errors — invalid operator operands,
+ * unreachable branches — still throw.
+ *
+ * Use this at internal boundaries where input/content failures are expected.
+ * Keep plain throws for programmer mistakes and impossible branches.
+ *
+ * @example
+ * const outcome = validateContentGraph(docs, config)
+ * if (!outcome.ok) {
+ *   return outcome // propagate up
+ * }
+ * useGraph(outcome.value)
+ */
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/** Produce a success result. Use at the emit site, not at call sites. */
+export declare const ok: <T>(value: T) => Result<T, never>;
+/** Produce a failure result. Use at the emit site, not at call sites. */
+export declare const fail: <E>(error: E) => Result<never, E>;

package/dist/core/result.js

@@ -0,0 +1,2 @@
+export const ok = (value) => ({ ok: true, value });
+export const fail = (error) => ({ ok: false, error });

package/dist/features/collections/resolve

@@ -0,0 +1 @@
+export * from './resolve.js'