@farm.js/content 0.1.0-beta.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,96 @@
+# `@farm.js/content`
+
+Load local Markdown, MDX, JSON, and YAML as schema-validated, typed content collections in Farm.js.
+
+## Install
+
+```bash
+pnpm add @farm.js/content zod
+```
+
+Zod is optional. Any Standard Schema-compatible validator works, as does an object with `parse` or
+`parseAsync`.
+
+## Configure
+
+Collections live directly in `farm.config.ts`. There is no required `content.config.ts` and no
+virtual module to import from application code.
+
+```ts
+import { asset, collection, content, files } from "@farm.js/content";
+import { defineConfig } from "@farm.js/core";
+import { z } from "zod";
+
+export default defineConfig({
+  plugins: [
+    content({
+      collections: {
+        posts: collection({
+          source: files("content/posts/**/*.{md,mdx}"),
+          schema: z.object({
+            title: z.string(),
+            publishedAt: z.coerce.date(),
+            tags: z.array(z.string()).default([]),
+          }),
+          assets: {
+            image: asset.image().optional(),
+            downloads: asset.files().default([]),
+          },
+          transform: ({ data, words }) => ({
+            ...data,
+            readingMinutes: Math.max(1, Math.ceil(words / 220)),
+          }),
+        }),
+      },
+    }),
+  ],
+});
+```
+
+For a large setup, move the ordinary collection objects to any application file and import the
+result into `farm.config.ts`. The filename is an application choice, not another framework config.
+
+## Read on the server
+
+```ts
+import { getCollection, getEntry, getEntryOrThrow } from "@farm.js/content/server";
+
+const posts = await getCollection("posts");
+const optionalPost = await getEntry("posts", "guides/getting-started");
+const post = await getEntryOrThrow("posts", "guides/getting-started");
+```
+
+Asset fields are written as ordinary relative frontmatter paths but resolve to typed metadata under
+`entry.data`. Keep those fields out of the Standard Schema object: `asset.image()` performs image
+validation and produces `src`, `width`, and `height`, while `asset.file()` produces file metadata.
+Plural helpers accept arrays, and declarations support `.optional()` and `.default(...)`.
+
+The same `assets` option processes relative Markdown image and file destinations automatically.
+Use `assets: true` when no typed frontmatter fields are needed. Farm emits content-hashed URLs,
+tracks the source files for development reloads, and exposes discovered metadata through
+`entry.bodyAssets`.
+
+`src/farm.d.ts` infers the collection name and final `data` type from `farm.config.ts`, including
+values added by `transform`. Run `farm generate` after adding the plugin if the development server
+has not generated the declaration yet.
+
+Entry IDs are project-route friendly. They are derived from the path below the source base, with
+the file extension and trailing `index` removed. For example,
+`content/posts/guides/index.mdx` becomes `guides`.
+
+## Runtime contract
+
+- Source files are parsed and validated during Farm configuration, not on each request.
+- Development watches supported content files, regenerates the private module, and reloads the page.
+- Managed assets are validated inside the project, emitted through Vite, and watched for changes.
+- Production bundles the validated collection into the server output, so source files do not need
+  to exist on the deployed filesystem.
+- Dates, bigints, arrays, plain objects, `undefined`, and primitive values keep their runtime types.
+- Functions, symbols, class instances, circular values, invalid dates, and non-finite numbers fail
+  with an actionable build error instead of silently changing shape.
+- `@farm.js/content/server` is server-only. Use it in Server Components, static path generation,
+  server queries, server functions, or API routes.
+
+The plugin returns Markdown or MDX in `entry.body`. It stays unchanged unless assets are enabled;
+then only managed Markdown destinations are replaced with emitted URLs. Rendering stays explicit so
+applications can choose their renderer, component mapping, and HTML security policy.

package/dist/assets.d.ts

@@ -0,0 +1,28 @@
+import type { ContentAssetField, ContentAssetFields, ContentFileAsset, ContentImageAsset } from "./types.js";
+export interface ContentAssetImport {
+    readonly token: string;
+    readonly filePath: string;
+}
+export interface ContentAssetContext {
+    readonly root: string;
+    readonly collectionName: string;
+    readonly sourceFile: string;
+    readonly sourceFiles: Set<string>;
+    readonly imports: Map<string, ContentAssetImport>;
+}
+export declare const asset: Readonly<{
+    image: () => ContentAssetField<ContentImageAsset, string>;
+    images: () => ContentAssetField<readonly ContentImageAsset[], readonly string[]>;
+    file: () => ContentAssetField<ContentFileAsset, string>;
+    files: () => ContentAssetField<readonly ContentFileAsset[], readonly string[]>;
+}>;
+export declare function normalizeContentAssetFields(input: unknown): ContentAssetFields;
+export declare function splitContentAssetInput(input: unknown, fields: ContentAssetFields): {
+    schemaInput: unknown;
+    assetInput: unknown;
+};
+export declare function resolveContentAssetFields(fields: ContentAssetFields, input: unknown, context: ContentAssetContext): Promise<Record<string, unknown>>;
+export declare function mergeContentAssetData(data: unknown, assets: Record<string, unknown>, context: ContentAssetContext): Record<string, unknown>;
+export declare function resolveContentAsset(reference: string, expectedKind: "image" | "file", context: ContentAssetContext, diagnosticPath: readonly string[]): Promise<ContentFileAsset | ContentImageAsset>;
+export declare function isContentAssetField(value: unknown): value is ContentAssetField<any, any>;
+//# sourceMappingURL=assets.d.ts.map

package/dist/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../src/assets.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;CACnD;AAyCD,eAAO,MAAM,KAAK;;;;;EAKhB,CAAC;AAEH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,kBAAkB,CA8B9E;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,kBAAkB,GACzB;IAAE,WAAW,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAsC/C;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAyBlC;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,EAAE,mBAAmB,GAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0CzB;AAED,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,OAAO,GAAG,MAAM,EAC9B,OAAO,EAAE,mBAAmB,EAC5B,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,OAAO,CAAC,gBAAgB,GAAG,iBAAiB,CAAC,CAsF/C;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC,CAYxF"}

package/dist/assets.js

@@ -0,0 +1,348 @@
+import { createHash } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { imageSize } from "image-size";
+const IMAGE_FORMATS = Object.freeze({
+    ".avif": { detected: ["heif"], type: "image/avif" },
+    ".bmp": { detected: ["bmp"], type: "image/bmp" },
+    ".gif": { detected: ["gif"], type: "image/gif" },
+    ".heic": { detected: ["heif"], type: "image/heic" },
+    ".heif": { detected: ["heif"], type: "image/heif" },
+    ".ico": { detected: ["ico"], type: "image/x-icon" },
+    ".jpe": { detected: ["jpg"], type: "image/jpeg" },
+    ".jpeg": { detected: ["jpg"], type: "image/jpeg" },
+    ".jpg": { detected: ["jpg"], type: "image/jpeg" },
+    ".png": { detected: ["png"], type: "image/png" },
+    ".svg": { detected: ["svg"], type: "image/svg+xml" },
+    ".tif": { detected: ["tiff"], type: "image/tiff" },
+    ".tiff": { detected: ["tiff"], type: "image/tiff" },
+    ".webp": { detected: ["webp"], type: "image/webp" },
+});
+const FILE_MIME_TYPES = Object.freeze({
+    ".avif": "image/avif",
+    ".css": "text/css",
+    ".csv": "text/csv",
+    ".gif": "image/gif",
+    ".html": "text/html",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".json": "application/json",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain",
+    ".webp": "image/webp",
+    ".xml": "application/xml",
+    ".zip": "application/zip",
+});
+export const asset = Object.freeze({
+    image: () => createAssetField("image", false),
+    images: () => createAssetField("image", true),
+    file: () => createAssetField("file", false),
+    files: () => createAssetField("file", true),
+});
+export function normalizeContentAssetFields(input) {
+    const ancestors = new Set();
+    function visit(value, fieldPath) {
+        if (!isPlainObject(value)) {
+            throw new TypeError(`Content assets ${fieldPath || "definition"} must be an object`);
+        }
+        if (ancestors.has(value)) {
+            throw new TypeError("Content assets definition cannot contain circular references");
+        }
+        ancestors.add(value);
+        try {
+            const result = Object.create(null);
+            for (const key of Object.keys(value)) {
+                if (!key.trim())
+                    throw new TypeError("Content asset field names cannot be empty");
+                const child = value[key];
+                result[key] = isContentAssetField(child)
+                    ? child
+                    : visit(child, fieldPath ? `${fieldPath}.${key}` : key);
+            }
+            if (Object.keys(result).length === 0) {
+                throw new TypeError(`Content assets ${fieldPath || "definition"} cannot be empty`);
+            }
+            return Object.freeze(result);
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    }
+    return visit(input, "");
+}
+export function splitContentAssetInput(input, fields) {
+    if (!isPlainObject(input)) {
+        throw new TypeError("frontmatter must be an object when typed assets are configured");
+    }
+    function split(value, declarations) {
+        const schema = copyRecord(value);
+        const assets = Object.create(null);
+        for (const [key, declaration] of Object.entries(declarations)) {
+            if (isContentAssetField(declaration)) {
+                assets[key] = value?.[key];
+                delete schema[key];
+                continue;
+            }
+            const child = value?.[key];
+            if (child !== undefined && !isPlainObject(child)) {
+                assets[key] = child;
+                delete schema[key];
+                continue;
+            }
+            const nested = split(child, declaration);
+            assets[key] = nested.assets;
+            if (child !== undefined) {
+                if (Object.keys(nested.schema).length > 0)
+                    schema[key] = nested.schema;
+                else
+                    delete schema[key];
+            }
+        }
+        return { schema, assets };
+    }
+    const splitValue = split(input, fields);
+    return { schemaInput: splitValue.schema, assetInput: splitValue.assets };
+}
+export async function resolveContentAssetFields(fields, input, context) {
+    if (!isPlainObject(input)) {
+        throw assetError(context, [], "Expected frontmatter asset values to be an object");
+    }
+    async function visit(declarations, values, fieldPath) {
+        const result = Object.create(null);
+        for (const [key, declaration] of Object.entries(declarations)) {
+            const nextPath = [...fieldPath, key];
+            const value = values[key];
+            if (isContentAssetField(declaration)) {
+                result[key] = await resolveDeclaredAsset(declaration, value, context, nextPath);
+            }
+            else {
+                if (!isPlainObject(value))
+                    throw assetError(context, nextPath, "Expected an object");
+                result[key] = await visit(declaration, value, nextPath);
+            }
+        }
+        return result;
+    }
+    return visit(fields, input, []);
+}
+export function mergeContentAssetData(data, assets, context) {
+    if (!isPlainObject(data)) {
+        throw assetError(context, [], "Schema output must be an object when typed assets are configured");
+    }
+    function merge(value, additions, fieldPath) {
+        const result = copyRecord(value);
+        for (const [key, addition] of Object.entries(additions)) {
+            const nextPath = [...fieldPath, key];
+            if (isPlainObject(addition) && !isResolvedAsset(addition)) {
+                const existing = result[key];
+                if (existing !== undefined && !isPlainObject(existing)) {
+                    throw assetError(context, nextPath, "Conflicts with the schema output");
+                }
+                result[key] = merge(existing ?? {}, addition, nextPath);
+            }
+            else {
+                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                    throw assetError(context, nextPath, "Conflicts with the schema output; remove this asset field from schema");
+                }
+                result[key] = addition;
+            }
+        }
+        return result;
+    }
+    return merge(data, assets, []);
+}
+export async function resolveContentAsset(reference, expectedKind, context, diagnosticPath) {
+    const parsed = parseRelativeAssetReference(reference, context, diagnosticPath);
+    const sourceDirectory = path.dirname(path.resolve(context.root, context.sourceFile));
+    const requestedPath = path.resolve(sourceDirectory, parsed.path);
+    assertInsideRoot(requestedPath, path.resolve(context.root), context, diagnosticPath);
+    context.sourceFiles.add(requestedPath);
+    let actualPath;
+    let fileStats;
+    try {
+        [actualPath, fileStats] = await Promise.all([realpath(requestedPath), stat(requestedPath)]);
+    }
+    catch (error) {
+        throw assetError(context, diagnosticPath, `Asset ${JSON.stringify(reference)} does not exist`, error);
+    }
+    const actualRoot = await realpath(context.root);
+    assertInsideRoot(actualPath, actualRoot, context, diagnosticPath);
+    context.sourceFiles.add(actualPath);
+    if (!fileStats.isFile()) {
+        throw assetError(context, diagnosticPath, `Asset ${JSON.stringify(reference)} is not a file`);
+    }
+    const bytes = await readFile(actualPath);
+    const token = registerAssetImport(actualPath, actualRoot, context.imports);
+    const common = {
+        src: `${token}${parsed.suffix}`,
+        source: reference,
+        name: path.basename(actualPath),
+        bytes: bytes.byteLength,
+    };
+    if (expectedKind === "file") {
+        return Object.freeze({
+            kind: "file",
+            ...common,
+            type: FILE_MIME_TYPES[path.extname(actualPath).toLowerCase()] ?? "application/octet-stream",
+        });
+    }
+    let dimensions;
+    try {
+        dimensions = imageSize(bytes);
+    }
+    catch (error) {
+        throw assetError(context, diagnosticPath, `Asset ${JSON.stringify(reference)} is not a supported image with intrinsic dimensions`, error);
+    }
+    if (!dimensions.width || !dimensions.height || !dimensions.type) {
+        throw assetError(context, diagnosticPath, `Asset ${JSON.stringify(reference)} does not have readable intrinsic dimensions`);
+    }
+    const extension = path.extname(actualPath).toLowerCase();
+    const format = IMAGE_FORMATS[extension];
+    if (!format) {
+        throw assetError(context, diagnosticPath, `Asset ${JSON.stringify(reference)} uses an unsupported image extension ${JSON.stringify(extension || "(none)")}`);
+    }
+    if (!format.detected.includes(dimensions.type)) {
+        throw assetError(context, diagnosticPath, `Asset ${JSON.stringify(reference)} has extension ${JSON.stringify(extension)} but contains a ${dimensions.type} image`);
+    }
+    return Object.freeze({
+        kind: "image",
+        ...common,
+        type: format.type,
+        width: dimensions.width,
+        height: dimensions.height,
+    });
+}
+export function isContentAssetField(value) {
+    if (!value || typeof value !== "object" || !("__farmContentAsset" in value))
+        return false;
+    const field = value;
+    const definition = field.__farmContentAsset;
+    return Boolean(definition &&
+        (definition.kind === "image" || definition.kind === "file") &&
+        typeof definition.multiple === "boolean" &&
+        typeof definition.optional === "boolean" &&
+        typeof field.optional === "function" &&
+        typeof field.default === "function");
+}
+function createAssetField(kind, multiple, options = {}) {
+    const definition = Object.freeze({
+        kind,
+        multiple,
+        optional: options.optional === true,
+        ...(options.defaultValue === undefined ? {} : { defaultValue: options.defaultValue }),
+    });
+    return Object.freeze({
+        __farmContentAsset: definition,
+        optional: () => createAssetField(kind, multiple, {
+            ...options,
+            optional: true,
+        }),
+        default: (value) => {
+            assertAssetDefault(value, multiple);
+            const defaultValue = Array.isArray(value) ? Object.freeze([...value]) : value;
+            return createAssetField(kind, multiple, {
+                optional: false,
+                defaultValue: defaultValue,
+            });
+        },
+    });
+}
+async function resolveDeclaredAsset(field, rawValue, context, fieldPath) {
+    const definition = field.__farmContentAsset;
+    const value = rawValue === undefined ? definition.defaultValue : rawValue;
+    if (value === undefined) {
+        if (definition.optional)
+            return undefined;
+        throw assetError(context, fieldPath, "Required asset is missing");
+    }
+    if (definition.multiple) {
+        if (!Array.isArray(value) ||
+            value.some((entry) => typeof entry !== "string" || !entry.trim())) {
+            throw assetError(context, fieldPath, "Expected an array of relative asset paths");
+        }
+        return Promise.all(value.map((entry, index) => resolveContentAsset(entry, definition.kind, context, [...fieldPath, String(index)])));
+    }
+    if (typeof value !== "string" || !value.trim()) {
+        throw assetError(context, fieldPath, "Expected a relative asset path");
+    }
+    return resolveContentAsset(value, definition.kind, context, fieldPath);
+}
+function parseRelativeAssetReference(reference, context, fieldPath) {
+    const value = reference.trim();
+    if (!value ||
+        value.startsWith("/") ||
+        value.startsWith("\\") ||
+        value.startsWith("#") ||
+        value.startsWith("?") ||
+        /^[A-Za-z][A-Za-z\d+.-]*:/.test(value)) {
+        throw assetError(context, fieldPath, `Expected a relative asset path, received ${JSON.stringify(reference)}`);
+    }
+    if (value.includes("\\")) {
+        throw assetError(context, fieldPath, "Asset paths must use forward slashes");
+    }
+    const suffixIndex = value.search(/[?#]/);
+    const rawPath = suffixIndex < 0 ? value : value.slice(0, suffixIndex);
+    const suffix = suffixIndex < 0 ? "" : value.slice(suffixIndex);
+    let decodedPath;
+    try {
+        decodedPath = decodeURIComponent(rawPath);
+    }
+    catch (error) {
+        throw assetError(context, fieldPath, `Asset path ${JSON.stringify(reference)} has invalid encoding`, error);
+    }
+    if (!decodedPath || decodedPath.includes("\0")) {
+        throw assetError(context, fieldPath, `Asset path ${JSON.stringify(reference)} is invalid`);
+    }
+    return { path: decodedPath, suffix };
+}
+function registerAssetImport(filePath, root, imports) {
+    const normalized = path.relative(root, filePath).replace(/\\/g, "/");
+    const token = `__FARM_CONTENT_ASSET_${createHash("sha256")
+        .update(normalized)
+        .digest("hex")
+        .slice(0, 20)}__`;
+    if (!imports.has(token))
+        imports.set(token, Object.freeze({ token, filePath }));
+    return token;
+}
+function assertInsideRoot(filePath, root, context, fieldPath) {
+    const relative = path.relative(root, filePath);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw assetError(context, fieldPath, "Asset path cannot leave the Farm project root");
+    }
+}
+function assetError(context, fieldPath, message, cause) {
+    const location = fieldPath.length ? `${fieldPath.join(".")}: ` : "";
+    return new Error(`[farm:content] Collection ${JSON.stringify(context.collectionName)} rejected ${context.sourceFile}: ${location}${message}`, cause === undefined ? undefined : { cause });
+}
+function assertAssetDefault(value, multiple) {
+    if (multiple) {
+        if (!Array.isArray(value) ||
+            value.some((entry) => typeof entry !== "string" || !entry.trim())) {
+            throw new TypeError("Content asset list defaults must contain relative path strings");
+        }
+        return;
+    }
+    if (typeof value !== "string" || !value.trim()) {
+        throw new TypeError("Content asset defaults must be relative path strings");
+    }
+}
+function copyRecord(value) {
+    const result = Object.create(null);
+    if (!value)
+        return result;
+    for (const key of Object.keys(value))
+        result[key] = value[key];
+    return result;
+}
+function isPlainObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isResolvedAsset(value) {
+    return (value.kind === "image" || value.kind === "file") && typeof value.src === "string";
+}

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+import type { ContentAssetsInput, ContentCollection, ContentCollectionInput, ContentDataWithAssets, ContentFileSource, ContentSchema, InferContentSchema } from "./types.js";
+export interface ContentFilesOptions {
+    /** Ignore globs, evaluated relative to the Farm project root. */
+    ignore?: string | readonly string[];
+    /** Directory used to derive entry IDs. Defaults to the common static directory of all globs. */
+    base?: string;
+}
+export declare function files(patterns: string | readonly string[], options?: ContentFilesOptions): ContentFileSource;
+export declare function collection<TSchema extends ContentSchema<any>, const TAssets extends ContentAssetsInput = undefined, TTransformed = ContentDataWithAssets<InferContentSchema<TSchema>, TAssets>>(input: ContentCollectionInput<TSchema, TTransformed, TAssets>): ContentCollection<TTransformed, InferContentSchema<TSchema>>;
+export declare function isSupportedContentFile(filePath: string): boolean;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAIpB,MAAM,WAAW,mBAAmB;IAClC,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IACpC,gGAAgG;IAChG,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,KAAK,CACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EACpC,OAAO,GAAE,mBAAwB,GAChC,iBAAiB,CAWnB;AAED,wBAAgB,UAAU,CACxB,OAAO,SAAS,aAAa,CAAC,GAAG,CAAC,EAClC,KAAK,CAAC,OAAO,SAAS,kBAAkB,GAAG,SAAS,EACpD,YAAY,GAAG,qBAAqB,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAE1E,KAAK,EAAE,sBAAsB,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,GAC5D,iBAAiB,CAAC,YAAY,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAgC9D;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEhE"}

package/dist/config.js

@@ -0,0 +1,73 @@
+import path from "node:path";
+import { normalizeContentAssetFields } from "./assets.js";
+const SUPPORTED_EXTENSIONS = new Set([".md", ".mdx", ".json", ".yaml", ".yml"]);
+export function files(patterns, options = {}) {
+    const normalizedPatterns = normalizePatterns(patterns, "patterns");
+    const ignore = normalizePatterns(options.ignore ?? [], "ignore", true);
+    const base = options.base === undefined ? undefined : normalizeRelativePath(options.base, "base");
+    return Object.freeze({
+        kind: "files",
+        patterns: Object.freeze(normalizedPatterns),
+        ignore: Object.freeze(ignore),
+        ...(base ? { base } : {}),
+    });
+}
+export function collection(input) {
+    if (!input || typeof input !== "object") {
+        throw new TypeError("Content collection must be an object");
+    }
+    if (input.source?.kind !== "files") {
+        throw new TypeError("Content collection source must come from files()");
+    }
+    if (!isContentSchema(input.schema)) {
+        throw new TypeError("Content collection schema must implement Standard Schema, parseAsync, or parse");
+    }
+    if (input.transform !== undefined && typeof input.transform !== "function") {
+        throw new TypeError("Content collection transform must be a function");
+    }
+    if (input.assets !== undefined && input.assets !== true && typeof input.assets !== "object") {
+        throw new TypeError("Content collection assets must be true or an asset declaration object");
+    }
+    const assets = input.assets === true
+        ? true
+        : input.assets === undefined
+            ? undefined
+            : normalizeContentAssetFields(input.assets);
+    return Object.freeze({
+        source: input.source,
+        schema: input.schema,
+        ...(assets === undefined ? {} : { assets }),
+        ...(input.transform ? { transform: input.transform } : {}),
+    });
+}
+export function isSupportedContentFile(filePath) {
+    return SUPPORTED_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+function isContentSchema(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const schema = value;
+    return (typeof schema["~standard"]?.validate === "function" ||
+        typeof schema.parseAsync === "function" ||
+        typeof schema.parse === "function");
+}
+function normalizePatterns(value, label, allowEmpty = false) {
+    const values = (Array.isArray(value) ? value : [value]).map((pattern) => normalizeRelativePath(pattern, label));
+    if (!allowEmpty && values.length === 0) {
+        throw new TypeError(`Content files ${label} must include at least one glob`);
+    }
+    return [...new Set(values)];
+}
+function normalizeRelativePath(value, label) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new TypeError(`Content files ${label} must contain non-empty paths`);
+    }
+    const normalized = value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+    if (path.posix.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized)) {
+        throw new TypeError(`Content files ${label} must be relative to the Farm project root`);
+    }
+    if (normalized.split("/").includes("..")) {
+        throw new TypeError(`Content files ${label} cannot leave the Farm project root`);
+    }
+    return normalized;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { asset } from "./assets.js";
+import { collection, files } from "./config.js";
+import type { ContentCollections, ContentOptions, ContentPlugin } from "./types.js";
+export { asset, collection, files };
+export type { ContentFilesOptions } from "./config.js";
+export type { AppContentEntry, AppContentRegistry, ContentAssetField, ContentAssetFields, ContentAssetsInput, ContentAssetValue, ContentCollection, ContentCollectionInput, ContentCollectionName, ContentCollections, ContentEntry, ContentFileAsset, ContentFileSource, ContentImageAsset, ContentOptions, ContentPlugin, ContentSchema, ContentTransformContext, InferContentCollectionEntry, InferContentAssetFields, InferContentRegistry, InferContentSchema, } from "./types.js";
+/** Load schema-validated local content as a typed server-only collection registry. */
+export declare function content<const TCollections extends ContentCollections>(options: ContentOptions<TCollections>): ContentPlugin<TCollections>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,KAAK,EAA0B,MAAM,aAAa,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAIpF,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;AACpC,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,2BAA2B,EAC3B,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAEpB,sFAAsF;AACtF,wBAAgB,OAAO,CAAC,KAAK,CAAC,YAAY,SAAS,kBAAkB,EACnE,OAAO,EAAE,cAAc,CAAC,YAAY,CAAC,GACpC,aAAa,CAAC,YAAY,CAAC,CA4G7B"}