@pro-laico/payload-seed 0.0.0

package/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-2026 Pro Laico LLC <contact@prolaico.com>
+
+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,9 @@
+# @pro-laico/payload-seed
+
+Type-safe database seeding for [Payload CMS](https://payloadcms.com/) — write seed data in `seed.ts` files, reference other docs with typed tokens instead of raw ids, attach upload files inline, and the plugin orders dependencies and creates everything.
+
+```bash
+pnpm add @pro-laico/payload-seed
+```
+
+**[Documentation →](https://payload-plugins.prolaico.com/docs/plugins/payload-seed)**

package/dist/bin/seed.d.ts

@@ -0,0 +1,9 @@
+import { type SanitizedConfig } from 'payload';
+/**
+ * Payload custom-bin entry. `seedPlugin` registers this under `config.bin` as the `seed`
+ * command, so `payload seed` runs the seed via the Local API — no per-project runner
+ * script. Behind the `ENABLE_SEED` guard (the seed is destructive). Reads the plugin
+ * options the project passed to `seedPlugin` from `config.custom.payloadSeed`.
+ */
+export declare const script: (config: SanitizedConfig) => Promise<void>;
+//# sourceMappingURL=seed.d.ts.map

package/dist/bin/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../src/bin/seed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAK1D;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAU,QAAQ,eAAe,KAAG,OAAO,CAAC,IAAI,CAoBlE,CAAA"}

package/dist/bin/seed.js

@@ -0,0 +1,36 @@
+import { getPayload } from "payload";
+import { seed } from "../engine/run.js";
+import { SEED_DISABLED_MESSAGE, seedingEnabled } from "../guard.js";
+/**
+ * Payload custom-bin entry. `seedPlugin` registers this under `config.bin` as the `seed`
+ * command, so `payload seed` runs the seed via the Local API — no per-project runner
+ * script. Behind the `ENABLE_SEED` guard (the seed is destructive). Reads the plugin
+ * options the project passed to `seedPlugin` from `config.custom.payloadSeed`.
+ */ export const script = async (config)=>{
+    if (!seedingEnabled()) {
+        console.error(SEED_DISABLED_MESSAGE);
+        process.exitCode = 1;
+        return;
+    }
+    const options = config.custom?.payloadSeed?.options ?? {};
+    const payload = await getPayload({
+        config
+    });
+    try {
+        const result = await seed({
+            payload,
+            options
+        });
+        // One human-sized summary line — the full result (created/order/deferred/skipped) is for
+        // programmatic consumers of `seed()`, not the terminal.
+        const total = Object.values(result.created).reduce((sum, n)=>sum + n, 0);
+        const skipped = result.skipped.length ? ` (${result.skipped.length} definition${result.skipped.length === 1 ? '' : 's'} skipped)` : '';
+        payload.logger.info(`[payload-seed] created ${total} docs across ${Object.keys(result.created).length} collections${skipped}`);
+    } finally{
+        // Close adapter connections so the process doesn't hang on open handles.
+        await payload.db.destroy?.();
+    }
+    process.exit(0);
+};
+
+//# sourceMappingURL=seed.js.map

package/dist/bin/seed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/seed.ts"],"sourcesContent":["import { getPayload, type SanitizedConfig } from 'payload'\nimport { seed } from '../engine/run'\nimport { SEED_DISABLED_MESSAGE, seedingEnabled } from '../guard'\nimport type { SeedPluginOptions } from '../options'\n\n/**\n * Payload custom-bin entry. `seedPlugin` registers this under `config.bin` as the `seed`\n * command, so `payload seed` runs the seed via the Local API — no per-project runner\n * script. Behind the `ENABLE_SEED` guard (the seed is destructive). Reads the plugin\n * options the project passed to `seedPlugin` from `config.custom.payloadSeed`.\n */\nexport const script = async (config: SanitizedConfig): Promise<void> => {\n  if (!seedingEnabled()) {\n    console.error(SEED_DISABLED_MESSAGE)\n    process.exitCode = 1\n    return\n  }\n  const options = (config.custom?.payloadSeed?.options ?? {}) as SeedPluginOptions\n  const payload = await getPayload({ config })\n  try {\n    const result = await seed({ payload, options })\n    // One human-sized summary line — the full result (created/order/deferred/skipped) is for\n    // programmatic consumers of `seed()`, not the terminal.\n    const total = Object.values(result.created).reduce((sum, n) => sum + n, 0)\n    const skipped = result.skipped.length ? ` (${result.skipped.length} definition${result.skipped.length === 1 ? '' : 's'} skipped)` : ''\n    payload.logger.info(`[payload-seed] created ${total} docs across ${Object.keys(result.created).length} collections${skipped}`)\n  } finally {\n    // Close adapter connections so the process doesn't hang on open handles.\n    await payload.db.destroy?.()\n  }\n  process.exit(0)\n}\n"],"names":["getPayload","seed","SEED_DISABLED_MESSAGE","seedingEnabled","script","config","console","error","process","exitCode","options","custom","payloadSeed","payload","result","total","Object","values","created","reduce","sum","n","skipped","length","logger","info","keys","db","destroy","exit"],"mappings":"AAAA,SAASA,UAAU,QAA8B,UAAS;AAC1D,SAASC,IAAI,QAAQ,mBAAe;AACpC,SAASC,qBAAqB,EAAEC,cAAc,QAAQ,cAAU;AAGhE;;;;;CAKC,GACD,OAAO,MAAMC,SAAS,OAAOC;IAC3B,IAAI,CAACF,kBAAkB;QACrBG,QAAQC,KAAK,CAACL;QACdM,QAAQC,QAAQ,GAAG;QACnB;IACF;IACA,MAAMC,UAAWL,OAAOM,MAAM,EAAEC,aAAaF,WAAW,CAAC;IACzD,MAAMG,UAAU,MAAMb,WAAW;QAAEK;IAAO;IAC1C,IAAI;QACF,MAAMS,SAAS,MAAMb,KAAK;YAAEY;YAASH;QAAQ;QAC7C,yFAAyF;QACzF,wDAAwD;QACxD,MAAMK,QAAQC,OAAOC,MAAM,CAACH,OAAOI,OAAO,EAAEC,MAAM,CAAC,CAACC,KAAKC,IAAMD,MAAMC,GAAG;QACxE,MAAMC,UAAUR,OAAOQ,OAAO,CAACC,MAAM,GAAG,CAAC,EAAE,EAAET,OAAOQ,OAAO,CAACC,MAAM,CAAC,WAAW,EAAET,OAAOQ,OAAO,CAACC,MAAM,KAAK,IAAI,KAAK,IAAI,SAAS,CAAC,GAAG;QACpIV,QAAQW,MAAM,CAACC,IAAI,CAAC,CAAC,uBAAuB,EAAEV,MAAM,aAAa,EAAEC,OAAOU,IAAI,CAACZ,OAAOI,OAAO,EAAEK,MAAM,CAAC,YAAY,EAAED,SAAS;IAC/H,SAAU;QACR,yEAAyE;QACzE,MAAMT,QAAQc,EAAE,CAACC,OAAO;IAC1B;IACApB,QAAQqB,IAAI,CAAC;AACf,EAAC"}

package/dist/components/SeedButton.d.ts

@@ -0,0 +1,11 @@
+import type React from 'react';
+export interface SeedButtonProps {
+    /** Endpoint URL the button POSTs to. Defaults to `<routes.api>/seed` from the admin config. */
+    endpoint?: string;
+}
+/** Admin dashboard button that triggers `POST /api/seed`. Injected via the plugin's
+ *  `adminButton` option, or registered manually in `admin.components.beforeDashboard`.
+ *  The seed wipes seeded collections, so the first click arms a confirm and the second runs. */
+export declare const SeedButton: React.FC<SeedButtonProps>;
+export default SeedButton;
+//# sourceMappingURL=SeedButton.d.ts.map

package/dist/components/SeedButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SeedButton.d.ts","sourceRoot":"","sources":["../../src/components/SeedButton.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA0B9B,MAAM,WAAW,eAAe;IAC9B,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;gGAEgG;AAChG,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAwDhD,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/components/SeedButton.js

@@ -0,0 +1,82 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { toast, useConfig } from "@payloadcms/ui";
+import { useCallback, useState } from "react";
+const SuccessMessage = ()=>/*#__PURE__*/ _jsxs("div", {
+        children: [
+            "Database seeded! You can now",
+            ' ',
+            /*#__PURE__*/ _jsx("a", {
+                target: "_blank",
+                href: "/",
+                rel: "noreferrer",
+                children: "visit your website"
+            })
+        ]
+    });
+const MAX_SHOWN_ISSUES = 5;
+const summarizeIssues = (issues)=>{
+    const shown = issues.slice(0, MAX_SHOWN_ISSUES);
+    const more = issues.length - shown.length;
+    return shown.join('\n') + (more > 0 ? `\n…and ${more} more` : '');
+};
+/** Admin dashboard button that triggers `POST /api/seed`. Injected via the plugin's
+ *  `adminButton` option, or registered manually in `admin.components.beforeDashboard`.
+ *  The seed wipes seeded collections, so the first click arms a confirm and the second runs. */ export const SeedButton = ({ endpoint })=>{
+    const { config } = useConfig();
+    const url = endpoint ?? `${config.serverURL ?? ''}${config.routes.api}/seed`;
+    const [seeded, setSeeded] = useState(false);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [confirming, setConfirming] = useState(false);
+    const handleClick = useCallback((e)=>{
+        e.preventDefault();
+        if (loading) return toast.info('Seeding already in progress.');
+        if (!confirming) return setConfirming(true);
+        setConfirming(false);
+        setError(null);
+        setLoading(true);
+        const run = fetch(url, {
+            method: 'POST',
+            credentials: 'include'
+        }).then(async (res)=>{
+            const body = await res.json().catch(()=>({}));
+            if (!res.ok) {
+                const base = body.error ?? 'An error occurred while seeding.';
+                throw new Error(body.issues?.length ? `${base}\n${summarizeIssues(body.issues)}` : base);
+            }
+            setSeeded(true);
+            return body;
+        }).catch((err)=>{
+            const wrapped = err instanceof Error ? err : new Error(String(err));
+            setError(wrapped.message);
+            throw wrapped;
+        }).finally(()=>setLoading(false));
+        toast.promise(run, {
+            loading: 'Seeding with data....',
+            success: (body)=>body.message ?? /*#__PURE__*/ _jsx(SuccessMessage, {}),
+            error: (err)=>err instanceof Error ? err.message : 'An error occurred while seeding.'
+        });
+    }, [
+        loading,
+        confirming,
+        url
+    ]);
+    let message = '';
+    if (seeded) message = ' (done — click to reseed)';
+    if (error) message = ` (error: ${error} — click to retry)`;
+    if (confirming) message = ' — click again to confirm: this wipes seeded collections';
+    if (loading) message = ' (seeding...)';
+    return /*#__PURE__*/ _jsxs("button", {
+        type: "button",
+        onClick: handleClick,
+        disabled: loading,
+        children: [
+            "Seed your database",
+            message
+        ]
+    });
+};
+export default SeedButton;
+
+//# sourceMappingURL=SeedButton.js.map

package/dist/components/SeedButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/components/SeedButton.tsx"],"sourcesContent":["'use client'\n\nimport { toast, useConfig } from '@payloadcms/ui'\nimport type React from 'react'\nimport { useCallback, useState } from 'react'\n\nconst SuccessMessage: React.FC = () => (\n  <div>\n    Database seeded! You can now{' '}\n    <a target=\"_blank\" href=\"/\" rel=\"noreferrer\">\n      visit your website\n    </a>\n  </div>\n)\n\nconst MAX_SHOWN_ISSUES = 5\n\nconst summarizeIssues = (issues: string[]): string => {\n  const shown = issues.slice(0, MAX_SHOWN_ISSUES)\n  const more = issues.length - shown.length\n  return shown.join('\\n') + (more > 0 ? `\\n…and ${more} more` : '')\n}\n\ninterface SeedResponseBody {\n  error?: string\n  issues?: string[]\n  message?: string\n}\n\nexport interface SeedButtonProps {\n  /** Endpoint URL the button POSTs to. Defaults to `<routes.api>/seed` from the admin config. */\n  endpoint?: string\n}\n\n/** Admin dashboard button that triggers `POST /api/seed`. Injected via the plugin's\n *  `adminButton` option, or registered manually in `admin.components.beforeDashboard`.\n *  The seed wipes seeded collections, so the first click arms a confirm and the second runs. */\nexport const SeedButton: React.FC<SeedButtonProps> = ({ endpoint }) => {\n  const { config } = useConfig()\n  const url = endpoint ?? `${config.serverURL ?? ''}${config.routes.api}/seed`\n  const [seeded, setSeeded] = useState(false)\n  const [loading, setLoading] = useState(false)\n  const [error, setError] = useState<null | string>(null)\n  const [confirming, setConfirming] = useState(false)\n\n  const handleClick = useCallback(\n    (e: React.MouseEvent<HTMLButtonElement>) => {\n      e.preventDefault()\n\n      if (loading) return toast.info('Seeding already in progress.')\n      if (!confirming) return setConfirming(true)\n\n      setConfirming(false)\n      setError(null)\n      setLoading(true)\n\n      const run = fetch(url, { method: 'POST', credentials: 'include' })\n        .then(async (res) => {\n          const body = (await res.json().catch(() => ({}))) as SeedResponseBody\n          if (!res.ok) {\n            const base = body.error ?? 'An error occurred while seeding.'\n            throw new Error(body.issues?.length ? `${base}\\n${summarizeIssues(body.issues)}` : base)\n          }\n          setSeeded(true)\n          return body\n        })\n        .catch((err) => {\n          const wrapped = err instanceof Error ? err : new Error(String(err))\n          setError(wrapped.message)\n          throw wrapped\n        })\n        .finally(() => setLoading(false))\n\n      toast.promise(run, {\n        loading: 'Seeding with data....',\n        success: (body) => body.message ?? <SuccessMessage />,\n        error: (err) => (err instanceof Error ? err.message : 'An error occurred while seeding.'),\n      })\n    },\n    [loading, confirming, url],\n  )\n\n  let message = ''\n  if (seeded) message = ' (done — click to reseed)'\n  if (error) message = ` (error: ${error} — click to retry)`\n  if (confirming) message = ' — click again to confirm: this wipes seeded collections'\n  if (loading) message = ' (seeding...)'\n\n  return (\n    <button type=\"button\" onClick={handleClick} disabled={loading}>\n      Seed your database{message}\n    </button>\n  )\n}\n\nexport default SeedButton\n"],"names":["toast","useConfig","useCallback","useState","SuccessMessage","div","a","target","href","rel","MAX_SHOWN_ISSUES","summarizeIssues","issues","shown","slice","more","length","join","SeedButton","endpoint","config","url","serverURL","routes","api","seeded","setSeeded","loading","setLoading","error","setError","confirming","setConfirming","handleClick","e","preventDefault","info","run","fetch","method","credentials","then","res","body","json","catch","ok","base","Error","err","wrapped","String","message","finally","promise","success","button","type","onClick","disabled"],"mappings":"AAAA;;AAEA,SAASA,KAAK,EAAEC,SAAS,QAAQ,iBAAgB;AAEjD,SAASC,WAAW,EAAEC,QAAQ,QAAQ,QAAO;AAE7C,MAAMC,iBAA2B,kBAC/B,MAACC;;YAAI;YAC0B;0BAC7B,KAACC;gBAAEC,QAAO;gBAASC,MAAK;gBAAIC,KAAI;0BAAa;;;;AAMjD,MAAMC,mBAAmB;AAEzB,MAAMC,kBAAkB,CAACC;IACvB,MAAMC,QAAQD,OAAOE,KAAK,CAAC,GAAGJ;IAC9B,MAAMK,OAAOH,OAAOI,MAAM,GAAGH,MAAMG,MAAM;IACzC,OAAOH,MAAMI,IAAI,CAAC,QAASF,CAAAA,OAAO,IAAI,CAAC,OAAO,EAAEA,KAAK,KAAK,CAAC,GAAG,EAAC;AACjE;AAaA;;8FAE8F,GAC9F,OAAO,MAAMG,aAAwC,CAAC,EAAEC,QAAQ,EAAE;IAChE,MAAM,EAAEC,MAAM,EAAE,GAAGnB;IACnB,MAAMoB,MAAMF,YAAY,GAAGC,OAAOE,SAAS,IAAI,KAAKF,OAAOG,MAAM,CAACC,GAAG,CAAC,KAAK,CAAC;IAC5E,MAAM,CAACC,QAAQC,UAAU,GAAGvB,SAAS;IACrC,MAAM,CAACwB,SAASC,WAAW,GAAGzB,SAAS;IACvC,MAAM,CAAC0B,OAAOC,SAAS,GAAG3B,SAAwB;IAClD,MAAM,CAAC4B,YAAYC,cAAc,GAAG7B,SAAS;IAE7C,MAAM8B,cAAc/B,YAClB,CAACgC;QACCA,EAAEC,cAAc;QAEhB,IAAIR,SAAS,OAAO3B,MAAMoC,IAAI,CAAC;QAC/B,IAAI,CAACL,YAAY,OAAOC,cAAc;QAEtCA,cAAc;QACdF,SAAS;QACTF,WAAW;QAEX,MAAMS,MAAMC,MAAMjB,KAAK;YAAEkB,QAAQ;YAAQC,aAAa;QAAU,GAC7DC,IAAI,CAAC,OAAOC;YACX,MAAMC,OAAQ,MAAMD,IAAIE,IAAI,GAAGC,KAAK,CAAC,IAAO,CAAA,CAAC,CAAA;YAC7C,IAAI,CAACH,IAAII,EAAE,EAAE;gBACX,MAAMC,OAAOJ,KAAKd,KAAK,IAAI;gBAC3B,MAAM,IAAImB,MAAML,KAAK/B,MAAM,EAAEI,SAAS,GAAG+B,KAAK,EAAE,EAAEpC,gBAAgBgC,KAAK/B,MAAM,GAAG,GAAGmC;YACrF;YACArB,UAAU;YACV,OAAOiB;QACT,GACCE,KAAK,CAAC,CAACI;YACN,MAAMC,UAAUD,eAAeD,QAAQC,MAAM,IAAID,MAAMG,OAAOF;YAC9DnB,SAASoB,QAAQE,OAAO;YACxB,MAAMF;QACR,GACCG,OAAO,CAAC,IAAMzB,WAAW;QAE5B5B,MAAMsD,OAAO,CAACjB,KAAK;YACjBV,SAAS;YACT4B,SAAS,CAACZ,OAASA,KAAKS,OAAO,kBAAI,KAAChD;YACpCyB,OAAO,CAACoB,MAASA,eAAeD,QAAQC,IAAIG,OAAO,GAAG;QACxD;IACF,GACA;QAACzB;QAASI;QAAYV;KAAI;IAG5B,IAAI+B,UAAU;IACd,IAAI3B,QAAQ2B,UAAU;IACtB,IAAIvB,OAAOuB,UAAU,CAAC,SAAS,EAAEvB,MAAM,kBAAkB,CAAC;IAC1D,IAAIE,YAAYqB,UAAU;IAC1B,IAAIzB,SAASyB,UAAU;IAEvB,qBACE,MAACI;QAAOC,MAAK;QAASC,SAASzB;QAAa0B,UAAUhC;;YAAS;YAC1CyB;;;AAGzB,EAAC;AAED,eAAelC,WAAU"}

package/dist/defineSeed.d.ts

@@ -0,0 +1,43 @@
+import type { CollectionSlug, GlobalSlug } from 'payload';
+import { file, ref } from './refs';
+import type { CollectionSeedData, CollectionSeedDefinition, GlobalSeedData, GlobalSeedDefinition, SeedDisabledMarker, SeedTokens } from './types';
+declare const tokens: {
+    ref: typeof ref;
+    file: typeof file;
+};
+type Exact<T, Shape> = T & Record<Exclude<keyof T, keyof Shape>, never>;
+type ExactEach<T extends readonly unknown[], Shape> = {
+    [I in keyof T]: Exact<T[I], Shape>;
+};
+type ShapeFor<TSlug> = TSlug extends CollectionSlug ? ReadonlyArray<CollectionSeedData<TSlug>> : TSlug extends GlobalSlug ? GlobalSeedData<TSlug> : never;
+type ExactFor<T, Shape> = Shape extends readonly unknown[] ? T extends readonly unknown[] ? ExactEach<T, Shape[number]> : never : Exact<T, Shape>;
+type DefinitionFor<TSlug> = TSlug extends CollectionSlug ? CollectionSeedDefinition<TSlug> : TSlug extends GlobalSlug ? GlobalSeedDefinition<TSlug> : never;
+/**
+ * Define seed data for a collection or a global. Pass the slug and a builder; the second parameter
+ * types itself from the slug — an array of records for a collection (each with a local `_key` handle
+ * and an optional `_file` attaching a source file), or a single data object for a global (no `_key`).
+ * Records are typed against the app's generated Payload types, relationship fields accept `ref()`
+ * tokens, and unknown fields are rejected. Default-export one per `seed.ts` file, then wire it into
+ * `seedPlugin({ definitions })`.
+ *
+ * This is a single call signature (not an overload set), so a bad field reports against the resolved
+ * record type — the same specific error the collection/global shapes give on their own.
+ *
+ *   export default defineSeed('images', ({ file }) => [
+ *     { _key: 'hero', _file: file('hero.jpg'), alt: 'A lighthouse at dusk' },
+ *   ])
+ *
+ *   export default defineSeed('site-settings', ({ ref }) => ({
+ *     featured: ref('services', 'consulting'),
+ *   }))
+ *
+ * `opts.disabled` skips the definition at seed time without removing it (so the generated seed-ref
+ * types stay stable) — the engine warns, and optional refs pointing at it are dropped. Collections
+ * that declare `custom.seedDisabled` (e.g. a plugin detecting missing credentials) are skipped the
+ * same way automatically, so you usually don't need to set this yourself.
+ */
+export declare function defineSeed<TSlug extends CollectionSlug | GlobalSlug, const T extends ShapeFor<TSlug>>(slug: TSlug, build: (tokens: SeedTokens) => ExactFor<T, ShapeFor<TSlug>>, opts?: {
+    disabled?: SeedDisabledMarker;
+}): DefinitionFor<TSlug>;
+export { tokens };
+//# sourceMappingURL=defineSeed.d.ts.map

package/dist/defineSeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineSeed.d.ts","sourceRoot":"","sources":["../src/defineSeed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzD,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,UAAU,EACX,MAAM,SAAS,CAAA;AAEhB,QAAA,MAAM,MAAM;;;CAAgB,CAAA;AAM5B,KAAK,KAAK,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,EAAE,KAAK,CAAC,CAAA;AACvE,KAAK,SAAS,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;CAAE,CAAA;AAK5F,KAAK,QAAQ,CAAC,KAAK,IAAI,KAAK,SAAS,cAAc,GAC/C,aAAa,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,GACxC,KAAK,SAAS,UAAU,GACtB,cAAc,CAAC,KAAK,CAAC,GACrB,KAAK,CAAA;AAIX,KAAK,QAAQ,CAAC,CAAC,EAAE,KAAK,IAAI,KAAK,SAAS,SAAS,OAAO,EAAE,GACtD,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1B,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,GAC3B,KAAK,GACP,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;AAGnB,KAAK,aAAa,CAAC,KAAK,IAAI,KAAK,SAAS,cAAc,GACpD,wBAAwB,CAAC,KAAK,CAAC,GAC/B,KAAK,SAAS,UAAU,GACtB,oBAAoB,CAAC,KAAK,CAAC,GAC3B,KAAK,CAAA;AAEX;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,cAAc,GAAG,UAAU,EAAE,KAAK,CAAC,CAAC,SAAS,QAAQ,CAAC,KAAK,CAAC,EACnG,IAAI,EAAE,KAAK,EACX,KAAK,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,EAC3D,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,kBAAkB,CAAA;CAAE,GACvC,aAAa,CAAC,KAAK,CAAC,CAYtB;AAED,OAAO,EAAE,MAAM,EAAE,CAAA"}

package/dist/defineSeed.js

@@ -0,0 +1,51 @@
+import { file, ref } from "./refs.js";
+const tokens = {
+    ref,
+    file
+};
+/**
+ * Define seed data for a collection or a global. Pass the slug and a builder; the second parameter
+ * types itself from the slug — an array of records for a collection (each with a local `_key` handle
+ * and an optional `_file` attaching a source file), or a single data object for a global (no `_key`).
+ * Records are typed against the app's generated Payload types, relationship fields accept `ref()`
+ * tokens, and unknown fields are rejected. Default-export one per `seed.ts` file, then wire it into
+ * `seedPlugin({ definitions })`.
+ *
+ * This is a single call signature (not an overload set), so a bad field reports against the resolved
+ * record type — the same specific error the collection/global shapes give on their own.
+ *
+ *   export default defineSeed('images', ({ file }) => [
+ *     { _key: 'hero', _file: file('hero.jpg'), alt: 'A lighthouse at dusk' },
+ *   ])
+ *
+ *   export default defineSeed('site-settings', ({ ref }) => ({
+ *     featured: ref('services', 'consulting'),
+ *   }))
+ *
+ * `opts.disabled` skips the definition at seed time without removing it (so the generated seed-ref
+ * types stay stable) — the engine warns, and optional refs pointing at it are dropped. Collections
+ * that declare `custom.seedDisabled` (e.g. a plugin detecting missing credentials) are skipped the
+ * same way automatically, so you usually don't need to set this yourself.
+ */ export function defineSeed(slug, build, opts) {
+    // Classify collection vs global from the builder's shape (collection → array, global → object).
+    // The ref/file tokens are pure constructors, so this eager call has no side effects and resolves
+    // no refs; it only decides `kind`. The engine calls `build` again at seed time.
+    let built;
+    try {
+        built = build(tokens);
+    } catch (e) {
+        throw new Error(`[payload-seed] defineSeed('${slug}'): builder threw during classification: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const kind = Array.isArray(built) ? 'collection' : 'global';
+    return {
+        kind,
+        slug,
+        build,
+        ...opts?.disabled !== undefined ? {
+            disabled: opts.disabled
+        } : {}
+    };
+}
+export { tokens };
+
+//# sourceMappingURL=defineSeed.js.map

package/dist/defineSeed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/defineSeed.ts"],"sourcesContent":["import type { CollectionSlug, GlobalSlug } from 'payload'\nimport { file, ref } from './refs'\nimport type {\n  CollectionSeedData,\n  CollectionSeedDefinition,\n  GlobalSeedData,\n  GlobalSeedDefinition,\n  SeedDisabledMarker,\n  SeedTokens,\n} from './types'\n\nconst tokens = { ref, file }\n\n// Re-enable excess-property checking, which TS disables for our mapped/intersection record\n// types: any key on `T` not present in `Shape` is forced to `never`, so a misspelled or\n// bogus field fails to type-check. (Wrong-*typed* values are already caught by the `extends`\n// constraint; this adds the missing unknown-*field* check.)\ntype Exact<T, Shape> = T & Record<Exclude<keyof T, keyof Shape>, never>\ntype ExactEach<T extends readonly unknown[], Shape> = { [I in keyof T]: Exact<T[I], Shape> }\n\n// The seed shape for a slug: an array of records for a collection, a single data object for a\n// global. Keyed on the slug, which is already pinned from the first argument by the time `build`\n// is checked, so the conditional collapses to one concrete branch.\ntype ShapeFor<TSlug> = TSlug extends CollectionSlug\n  ? ReadonlyArray<CollectionSeedData<TSlug>>\n  : TSlug extends GlobalSlug\n    ? GlobalSeedData<TSlug>\n    : never\n\n// Apply the excess-field check to whichever branch `ShapeFor` resolved to (per-record for a\n// collection array, whole-object for a global).\ntype ExactFor<T, Shape> = Shape extends readonly unknown[]\n  ? T extends readonly unknown[]\n    ? ExactEach<T, Shape[number]>\n    : never\n  : Exact<T, Shape>\n\n// The definition a given slug produces, so the return type discriminates like the data does.\ntype DefinitionFor<TSlug> = TSlug extends CollectionSlug\n  ? CollectionSeedDefinition<TSlug>\n  : TSlug extends GlobalSlug\n    ? GlobalSeedDefinition<TSlug>\n    : never\n\n/**\n * Define seed data for a collection or a global. Pass the slug and a builder; the second parameter\n * types itself from the slug — an array of records for a collection (each with a local `_key` handle\n * and an optional `_file` attaching a source file), or a single data object for a global (no `_key`).\n * Records are typed against the app's generated Payload types, relationship fields accept `ref()`\n * tokens, and unknown fields are rejected. Default-export one per `seed.ts` file, then wire it into\n * `seedPlugin({ definitions })`.\n *\n * This is a single call signature (not an overload set), so a bad field reports against the resolved\n * record type — the same specific error the collection/global shapes give on their own.\n *\n *   export default defineSeed('images', ({ file }) => [\n *     { _key: 'hero', _file: file('hero.jpg'), alt: 'A lighthouse at dusk' },\n *   ])\n *\n *   export default defineSeed('site-settings', ({ ref }) => ({\n *     featured: ref('services', 'consulting'),\n *   }))\n *\n * `opts.disabled` skips the definition at seed time without removing it (so the generated seed-ref\n * types stay stable) — the engine warns, and optional refs pointing at it are dropped. Collections\n * that declare `custom.seedDisabled` (e.g. a plugin detecting missing credentials) are skipped the\n * same way automatically, so you usually don't need to set this yourself.\n */\nexport function defineSeed<TSlug extends CollectionSlug | GlobalSlug, const T extends ShapeFor<TSlug>>(\n  slug: TSlug,\n  build: (tokens: SeedTokens) => ExactFor<T, ShapeFor<TSlug>>,\n  opts?: { disabled?: SeedDisabledMarker },\n): DefinitionFor<TSlug> {\n  // Classify collection vs global from the builder's shape (collection → array, global → object).\n  // The ref/file tokens are pure constructors, so this eager call has no side effects and resolves\n  // no refs; it only decides `kind`. The engine calls `build` again at seed time.\n  let built: unknown\n  try {\n    built = (build as (t: SeedTokens) => unknown)(tokens)\n  } catch (e) {\n    throw new Error(`[payload-seed] defineSeed('${slug}'): builder threw during classification: ${e instanceof Error ? e.message : String(e)}`)\n  }\n  const kind = Array.isArray(built) ? 'collection' : 'global'\n  return { kind, slug, build, ...(opts?.disabled !== undefined ? { disabled: opts.disabled } : {}) } as unknown as DefinitionFor<TSlug>\n}\n\nexport { tokens }\n"],"names":["file","ref","tokens","defineSeed","slug","build","opts","built","e","Error","message","String","kind","Array","isArray","disabled","undefined"],"mappings":"AACA,SAASA,IAAI,EAAEC,GAAG,QAAQ,YAAQ;AAUlC,MAAMC,SAAS;IAAED;IAAKD;AAAK;AAiC3B;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASG,WACdC,IAAW,EACXC,KAA2D,EAC3DC,IAAwC;IAExC,gGAAgG;IAChG,iGAAiG;IACjG,gFAAgF;IAChF,IAAIC;IACJ,IAAI;QACFA,QAAQ,AAACF,MAAqCH;IAChD,EAAE,OAAOM,GAAG;QACV,MAAM,IAAIC,MAAM,CAAC,2BAA2B,EAAEL,KAAK,yCAAyC,EAAEI,aAAaC,QAAQD,EAAEE,OAAO,GAAGC,OAAOH,IAAI;IAC5I;IACA,MAAMI,OAAOC,MAAMC,OAAO,CAACP,SAAS,eAAe;IACnD,OAAO;QAAEK;QAAMR;QAAMC;QAAO,GAAIC,MAAMS,aAAaC,YAAY;YAAED,UAAUT,KAAKS,QAAQ;QAAC,IAAI,CAAC,CAAC;IAAE;AACnG;AAEA,SAASb,MAAM,GAAE"}

package/dist/endpoint.d.ts

@@ -0,0 +1,10 @@
+import type { Endpoint } from 'payload';
+import type { ResolvedSeedOptions } from './options';
+/**
+ * Builds `POST /api/seed`. Gated by the `ENABLE_SEED` runtime guard and requires an
+ * authenticated user (any user — not necessarily an admin). Each write sets
+ * `context.disableRevalidate`, so app revalidate hooks skip during the run; the engine
+ * does no final revalidation.
+ */
+export declare function createSeedEndpoint(options: ResolvedSeedOptions): Endpoint;
+//# sourceMappingURL=endpoint.d.ts.map

package/dist/endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint.d.ts","sourceRoot":"","sources":["../src/endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAIvC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAEpD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CAoBzE"}

package/dist/endpoint.js

@@ -0,0 +1,60 @@
+import { runSeed } from "./engine/run.js";
+import { SeedValidationError } from "./engine/validate.js";
+import { SEED_DISABLED_MESSAGE, seedingEnabled } from "./guard.js";
+/**
+ * Builds `POST /api/seed`. Gated by the `ENABLE_SEED` runtime guard and requires an
+ * authenticated user (any user — not necessarily an admin). Each write sets
+ * `context.disableRevalidate`, so app revalidate hooks skip during the run; the engine
+ * does no final revalidation.
+ */ export function createSeedEndpoint(options) {
+    return {
+        path: '/seed',
+        method: 'post',
+        handler: async (req)=>{
+            if (!seedingEnabled()) return Response.json({
+                error: SEED_DISABLED_MESSAGE
+            }, {
+                status: 403
+            });
+            if (!req.user) return Response.json({
+                error: 'Seeding requires an authenticated Payload user (any user) - log in first.'
+            }, {
+                status: 403
+            });
+            try {
+                const result = await runSeed({
+                    payload: req.payload,
+                    req,
+                    options,
+                    definitions: options.definitions
+                });
+                const message = options.definitions?.length ? undefined : '0 documents created — no seed definitions registered';
+                return Response.json({
+                    success: true,
+                    ...message ? {
+                        message
+                    } : {},
+                    ...result
+                });
+            } catch (e) {
+                req.payload.logger.error({
+                    err: e,
+                    msg: 'Error seeding data'
+                });
+                if (e instanceof SeedValidationError) return Response.json({
+                    error: 'Seed validation failed.',
+                    issues: e.issues
+                }, {
+                    status: 400
+                });
+                return Response.json({
+                    error: 'Error seeding data.'
+                }, {
+                    status: 500
+                });
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=endpoint.js.map

package/dist/endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endpoint.ts"],"sourcesContent":["import type { Endpoint } from 'payload'\nimport { runSeed } from './engine/run'\nimport { SeedValidationError } from './engine/validate'\nimport { SEED_DISABLED_MESSAGE, seedingEnabled } from './guard'\nimport type { ResolvedSeedOptions } from './options'\n\n/**\n * Builds `POST /api/seed`. Gated by the `ENABLE_SEED` runtime guard and requires an\n * authenticated user (any user — not necessarily an admin). Each write sets\n * `context.disableRevalidate`, so app revalidate hooks skip during the run; the engine\n * does no final revalidation.\n */\nexport function createSeedEndpoint(options: ResolvedSeedOptions): Endpoint {\n  return {\n    path: '/seed',\n    method: 'post',\n    handler: async (req) => {\n      if (!seedingEnabled()) return Response.json({ error: SEED_DISABLED_MESSAGE }, { status: 403 })\n      if (!req.user)\n        return Response.json({ error: 'Seeding requires an authenticated Payload user (any user) - log in first.' }, { status: 403 })\n\n      try {\n        const result = await runSeed({ payload: req.payload, req, options, definitions: options.definitions })\n        const message = options.definitions?.length ? undefined : '0 documents created — no seed definitions registered'\n        return Response.json({ success: true, ...(message ? { message } : {}), ...result })\n      } catch (e) {\n        req.payload.logger.error({ err: e, msg: 'Error seeding data' })\n        if (e instanceof SeedValidationError) return Response.json({ error: 'Seed validation failed.', issues: e.issues }, { status: 400 })\n        return Response.json({ error: 'Error seeding data.' }, { status: 500 })\n      }\n    },\n  }\n}\n"],"names":["runSeed","SeedValidationError","SEED_DISABLED_MESSAGE","seedingEnabled","createSeedEndpoint","options","path","method","handler","req","Response","json","error","status","user","result","payload","definitions","message","length","undefined","success","e","logger","err","msg","issues"],"mappings":"AACA,SAASA,OAAO,QAAQ,kBAAc;AACtC,SAASC,mBAAmB,QAAQ,uBAAmB;AACvD,SAASC,qBAAqB,EAAEC,cAAc,QAAQ,aAAS;AAG/D;;;;;CAKC,GACD,OAAO,SAASC,mBAAmBC,OAA4B;IAC7D,OAAO;QACLC,MAAM;QACNC,QAAQ;QACRC,SAAS,OAAOC;YACd,IAAI,CAACN,kBAAkB,OAAOO,SAASC,IAAI,CAAC;gBAAEC,OAAOV;YAAsB,GAAG;gBAAEW,QAAQ;YAAI;YAC5F,IAAI,CAACJ,IAAIK,IAAI,EACX,OAAOJ,SAASC,IAAI,CAAC;gBAAEC,OAAO;YAA4E,GAAG;gBAAEC,QAAQ;YAAI;YAE7H,IAAI;gBACF,MAAME,SAAS,MAAMf,QAAQ;oBAAEgB,SAASP,IAAIO,OAAO;oBAAEP;oBAAKJ;oBAASY,aAAaZ,QAAQY,WAAW;gBAAC;gBACpG,MAAMC,UAAUb,QAAQY,WAAW,EAAEE,SAASC,YAAY;gBAC1D,OAAOV,SAASC,IAAI,CAAC;oBAAEU,SAAS;oBAAM,GAAIH,UAAU;wBAAEA;oBAAQ,IAAI,CAAC,CAAC;oBAAG,GAAGH,MAAM;gBAAC;YACnF,EAAE,OAAOO,GAAG;gBACVb,IAAIO,OAAO,CAACO,MAAM,CAACX,KAAK,CAAC;oBAAEY,KAAKF;oBAAGG,KAAK;gBAAqB;gBAC7D,IAAIH,aAAarB,qBAAqB,OAAOS,SAASC,IAAI,CAAC;oBAAEC,OAAO;oBAA2Bc,QAAQJ,EAAEI,MAAM;gBAAC,GAAG;oBAAEb,QAAQ;gBAAI;gBACjI,OAAOH,SAASC,IAAI,CAAC;oBAAEC,OAAO;gBAAsB,GAAG;oBAAEC,QAAQ;gBAAI;YACvE;QACF;IACF;AACF"}

package/dist/engine/files.d.ts

@@ -0,0 +1,15 @@
+import type { File } from 'payload';
+/** The directories `resolveFilePath` searches for a name, so a missing-file warning can list them. */
+export declare const searchedDirs: (name: string, assetsRoot: string, subdirs: string[]) => string[];
+/**
+ * Resolve a `_file` name to an absolute path on disk. `subdirs` is the ordered list of directories
+ * under the assets root to search — typically a collection's subdir then the root (`['media', '']`).
+ * The name may include a relative subpath (`portraits/jane.jpg`), resolved under each search dir, so
+ * a collection folder can be subdivided further. Tolerates an extension mismatch for image files (a
+ * name of `foo.png` picks up `foo.jpg`). Returns null when nothing matches; an absolute name is
+ * returned as-is.
+ */
+export declare function resolveFilePath(name: string, assetsRoot: string, subdirs: string[]): Promise<string | null>;
+/** Read a resolved path into a Payload `File` (for a native upload's `file` param). */
+export declare function readFileAsUpload(path: string): Promise<File>;
+//# sourceMappingURL=files.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../src/engine/files.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAyBnC,sGAAsG;AACtG,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,YAAY,MAAM,EAAE,SAAS,MAAM,EAAE,KAAG,MAAM,EAC7B,CAAA;AAE5D;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmBjH;AAED,uFAAuF;AACvF,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKlE"}

package/dist/engine/files.js

@@ -0,0 +1,72 @@
+import { readFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join } from "node:path";
+// MIME type derived from the file's real extension — we upload whatever the source is
+// (JPEG/PNG/WebP/SVG/WOFF2/…), not an assumed format.
+const MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.woff2': 'font/woff2',
+    '.woff': 'font/woff',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf'
+};
+// Extensions eligible for the same-basename sibling fallback in `resolveFilePath` — image formats
+// only, where `foo.png` picking up `foo.jpg` is a convenience. Fonts are matched by exact name so a
+// requested format is never silently swapped for another.
+const TOLERANT_EXTS = new Set([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.webp',
+    '.avif',
+    '.gif',
+    '.svg'
+]);
+const stripExt = (name)=>name.slice(0, name.length - extname(name).length);
+/** The directories `resolveFilePath` searches for a name, so a missing-file warning can list them. */ export const searchedDirs = (name, assetsRoot, subdirs)=>subdirs.map((sub)=>join(assetsRoot, sub, dirname(name)));
+/**
+ * Resolve a `_file` name to an absolute path on disk. `subdirs` is the ordered list of directories
+ * under the assets root to search — typically a collection's subdir then the root (`['media', '']`).
+ * The name may include a relative subpath (`portraits/jane.jpg`), resolved under each search dir, so
+ * a collection folder can be subdivided further. Tolerates an extension mismatch for image files (a
+ * name of `foo.png` picks up `foo.jpg`). Returns null when nothing matches; an absolute name is
+ * returned as-is.
+ */ export async function resolveFilePath(name, assetsRoot, subdirs) {
+    if (isAbsolute(name)) return name;
+    const { readdir } = await import("node:fs/promises");
+    const nameDir = dirname(name) // '.' for a bare filename, else the subpath (e.g. 'portraits')
+    ;
+    const fileName = basename(name);
+    const wantBase = stripExt(fileName);
+    for (const sub of subdirs){
+        const dir = join(assetsRoot, sub, nameDir);
+        let entries;
+        try {
+            entries = await readdir(dir);
+        } catch  {
+            continue;
+        }
+        if (entries.includes(fileName)) return join(dir, fileName);
+        const sibling = entries.find((e)=>stripExt(e) === wantBase && TOLERANT_EXTS.has(extname(e).toLowerCase()));
+        if (sibling) return join(dir, sibling);
+    }
+    return null;
+}
+/** Read a resolved path into a Payload `File` (for a native upload's `file` param). */ export async function readFileAsUpload(path) {
+    const data = await readFile(path);
+    const name = path.split(/[\\/]/).pop() ?? path;
+    const mimetype = MIME_BY_EXT[extname(path).toLowerCase()] ?? 'application/octet-stream';
+    return {
+        name,
+        data,
+        mimetype,
+        size: data.byteLength
+    };
+}
+
+//# sourceMappingURL=files.js.map

package/dist/engine/files.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/engine/files.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises'\nimport { basename, dirname, extname, isAbsolute, join } from 'node:path'\nimport type { File } from 'payload'\n\n// MIME type derived from the file's real extension — we upload whatever the source is\n// (JPEG/PNG/WebP/SVG/WOFF2/…), not an assumed format.\nconst MIME_BY_EXT: Record<string, string> = {\n  '.png': 'image/png',\n  '.jpg': 'image/jpeg',\n  '.jpeg': 'image/jpeg',\n  '.webp': 'image/webp',\n  '.avif': 'image/avif',\n  '.gif': 'image/gif',\n  '.svg': 'image/svg+xml',\n  '.woff2': 'font/woff2',\n  '.woff': 'font/woff',\n  '.ttf': 'font/ttf',\n  '.otf': 'font/otf',\n}\n\n// Extensions eligible for the same-basename sibling fallback in `resolveFilePath` — image formats\n// only, where `foo.png` picking up `foo.jpg` is a convenience. Fonts are matched by exact name so a\n// requested format is never silently swapped for another.\nconst TOLERANT_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.avif', '.gif', '.svg'])\n\nconst stripExt = (name: string) => name.slice(0, name.length - extname(name).length)\n\n/** The directories `resolveFilePath` searches for a name, so a missing-file warning can list them. */\nexport const searchedDirs = (name: string, assetsRoot: string, subdirs: string[]): string[] =>\n  subdirs.map((sub) => join(assetsRoot, sub, dirname(name)))\n\n/**\n * Resolve a `_file` name to an absolute path on disk. `subdirs` is the ordered list of directories\n * under the assets root to search — typically a collection's subdir then the root (`['media', '']`).\n * The name may include a relative subpath (`portraits/jane.jpg`), resolved under each search dir, so\n * a collection folder can be subdivided further. Tolerates an extension mismatch for image files (a\n * name of `foo.png` picks up `foo.jpg`). Returns null when nothing matches; an absolute name is\n * returned as-is.\n */\nexport async function resolveFilePath(name: string, assetsRoot: string, subdirs: string[]): Promise<string | null> {\n  if (isAbsolute(name)) return name\n  const { readdir } = await import('node:fs/promises')\n  const nameDir = dirname(name) // '.' for a bare filename, else the subpath (e.g. 'portraits')\n  const fileName = basename(name)\n  const wantBase = stripExt(fileName)\n  for (const sub of subdirs) {\n    const dir = join(assetsRoot, sub, nameDir)\n    let entries: string[]\n    try {\n      entries = await readdir(dir)\n    } catch {\n      continue\n    }\n    if (entries.includes(fileName)) return join(dir, fileName)\n    const sibling = entries.find((e) => stripExt(e) === wantBase && TOLERANT_EXTS.has(extname(e).toLowerCase()))\n    if (sibling) return join(dir, sibling)\n  }\n  return null\n}\n\n/** Read a resolved path into a Payload `File` (for a native upload's `file` param). */\nexport async function readFileAsUpload(path: string): Promise<File> {\n  const data = await readFile(path)\n  const name = path.split(/[\\\\/]/).pop() ?? path\n  const mimetype = MIME_BY_EXT[extname(path).toLowerCase()] ?? 'application/octet-stream'\n  return { name, data, mimetype, size: data.byteLength }\n}\n"],"names":["readFile","basename","dirname","extname","isAbsolute","join","MIME_BY_EXT","TOLERANT_EXTS","Set","stripExt","name","slice","length","searchedDirs","assetsRoot","subdirs","map","sub","resolveFilePath","readdir","nameDir","fileName","wantBase","dir","entries","includes","sibling","find","e","has","toLowerCase","readFileAsUpload","path","data","split","pop","mimetype","size","byteLength"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,mBAAkB;AAC3C,SAASC,QAAQ,EAAEC,OAAO,EAAEC,OAAO,EAAEC,UAAU,EAAEC,IAAI,QAAQ,YAAW;AAGxE,sFAAsF;AACtF,sDAAsD;AACtD,MAAMC,cAAsC;IAC1C,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,SAAS;IACT,SAAS;IACT,QAAQ;IACR,QAAQ;IACR,UAAU;IACV,SAAS;IACT,QAAQ;IACR,QAAQ;AACV;AAEA,kGAAkG;AAClG,oGAAoG;AACpG,0DAA0D;AAC1D,MAAMC,gBAAgB,IAAIC,IAAI;IAAC;IAAQ;IAAQ;IAAS;IAAS;IAAS;IAAQ;CAAO;AAEzF,MAAMC,WAAW,CAACC,OAAiBA,KAAKC,KAAK,CAAC,GAAGD,KAAKE,MAAM,GAAGT,QAAQO,MAAME,MAAM;AAEnF,oGAAoG,GACpG,OAAO,MAAMC,eAAe,CAACH,MAAcI,YAAoBC,UAC7DA,QAAQC,GAAG,CAAC,CAACC,MAAQZ,KAAKS,YAAYG,KAAKf,QAAQQ,QAAO;AAE5D;;;;;;;CAOC,GACD,OAAO,eAAeQ,gBAAgBR,IAAY,EAAEI,UAAkB,EAAEC,OAAiB;IACvF,IAAIX,WAAWM,OAAO,OAAOA;IAC7B,MAAM,EAAES,OAAO,EAAE,GAAG,MAAM,MAAM,CAAC;IACjC,MAAMC,UAAUlB,QAAQQ,MAAM,+DAA+D;;IAC7F,MAAMW,WAAWpB,SAASS;IAC1B,MAAMY,WAAWb,SAASY;IAC1B,KAAK,MAAMJ,OAAOF,QAAS;QACzB,MAAMQ,MAAMlB,KAAKS,YAAYG,KAAKG;QAClC,IAAII;QACJ,IAAI;YACFA,UAAU,MAAML,QAAQI;QAC1B,EAAE,OAAM;YACN;QACF;QACA,IAAIC,QAAQC,QAAQ,CAACJ,WAAW,OAAOhB,KAAKkB,KAAKF;QACjD,MAAMK,UAAUF,QAAQG,IAAI,CAAC,CAACC,IAAMnB,SAASmB,OAAON,YAAYf,cAAcsB,GAAG,CAAC1B,QAAQyB,GAAGE,WAAW;QACxG,IAAIJ,SAAS,OAAOrB,KAAKkB,KAAKG;IAChC;IACA,OAAO;AACT;AAEA,qFAAqF,GACrF,OAAO,eAAeK,iBAAiBC,IAAY;IACjD,MAAMC,OAAO,MAAMjC,SAASgC;IAC5B,MAAMtB,OAAOsB,KAAKE,KAAK,CAAC,SAASC,GAAG,MAAMH;IAC1C,MAAMI,WAAW9B,WAAW,CAACH,QAAQ6B,MAAMF,WAAW,GAAG,IAAI;IAC7D,OAAO;QAAEpB;QAAMuB;QAAMG;QAAUC,MAAMJ,KAAKK,UAAU;IAAC;AACvD"}

package/dist/engine/graph.d.ts

@@ -0,0 +1,61 @@
+import type { FileToken } from '../refs';
+export interface BuiltRecord {
+    key: string;
+    /** The record's `_file` meta-key, if it attaches a source file. */
+    file?: FileToken;
+    data: Record<string, unknown>;
+}
+export interface BuiltCollection {
+    slug: string;
+    records: BuiltRecord[];
+}
+export interface BuiltGlobal {
+    slug: string;
+    data: Record<string, unknown>;
+}
+export interface BuiltModel {
+    collections: BuiltCollection[];
+    globals: BuiltGlobal[];
+}
+export type GraphNodeType = 'doc' | 'global';
+export interface GraphNode {
+    id: string;
+    type: GraphNodeType;
+    label: string;
+    collection?: string;
+    slug?: string;
+    key?: string;
+}
+export interface GraphEdge {
+    from: string;
+    to: string;
+}
+/** A doc field whose refs were deferred to break a dependency cycle: created null, then set in a
+ *  second pass once every doc exists. `node` is the owning doc (`collection:_key`); `field` its top-level field. */
+export interface DeferredField {
+    node: string;
+    field: string;
+}
+export interface SeedGraph {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    /** Doc node ids in dependency-first create order. */
+    order: string[];
+    /** Fields deferred to break cycles (empty when the graph is acyclic). */
+    deferred: DeferredField[];
+}
+/** Whether a top-level field is required (so its refs can't be deferred). Defaults to treating every
+ *  field as required — i.e. no field is deferrable, so any cycle is a hard error (the strict default).
+ *  The engine passes a real lookup (from the live config) to enable optional-field cycle breaking. */
+export type RequiredLookup = (collection: string, field: string) => boolean;
+/**
+ * Build the dependency graph: doc/global nodes, edges from each doc/global to the docs it
+ * references, and the topologically sorted doc create order. When a `ref` cycle exists, an optional
+ * field on one edge of the cycle is **deferred** (its refs set in a second pass) to break it; a cycle
+ * with no optional field to break is a hard error. Pass `isRequired` to enable this — without it every
+ * field is treated as required, so any cycle throws.
+ */
+export declare function buildGraph(model: BuiltModel, opts?: {
+    isRequired?: RequiredLookup;
+}): SeedGraph;
+//# sourceMappingURL=graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/engine/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxC,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,mEAAmE;IACnE,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B;AACD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,WAAW,EAAE,CAAA;CACvB;AACD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B;AACD,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,eAAe,EAAE,CAAA;IAC9B,OAAO,EAAE,WAAW,EAAE,CAAA;CACvB;AAED,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,QAAQ,CAAA;AAC5C,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,aAAa,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AACD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX;AAED;oHACoH;AACpH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,qDAAqD;IACrD,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,yEAAyE;IACzE,QAAQ,EAAE,aAAa,EAAE,CAAA;CAC1B;AAED;;sGAEsG;AACtG,MAAM,MAAM,cAAc,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;AAK3E;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,cAAc,CAAA;CAAO,GAAG,SAAS,CA8CnG"}

package/dist/engine/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/engine/graph.ts"],"sourcesContent":["import type { FileToken } from '../refs'\nimport { collectTokens, docNodeId } from './tokens'\n\nexport interface BuiltRecord {\n  key: string\n  /** The record's `_file` meta-key, if it attaches a source file. */\n  file?: FileToken\n  data: Record<string, unknown>\n}\nexport interface BuiltCollection {\n  slug: string\n  records: BuiltRecord[]\n}\nexport interface BuiltGlobal {\n  slug: string\n  data: Record<string, unknown>\n}\nexport interface BuiltModel {\n  collections: BuiltCollection[]\n  globals: BuiltGlobal[]\n}\n\nexport type GraphNodeType = 'doc' | 'global'\nexport interface GraphNode {\n  id: string\n  type: GraphNodeType\n  label: string\n  collection?: string\n  slug?: string\n  key?: string\n}\nexport interface GraphEdge {\n  from: string\n  to: string\n}\n\n/** A doc field whose refs were deferred to break a dependency cycle: created null, then set in a\n *  second pass once every doc exists. `node` is the owning doc (`collection:_key`); `field` its top-level field. */\nexport interface DeferredField {\n  node: string\n  field: string\n}\n\nexport interface SeedGraph {\n  nodes: GraphNode[]\n  edges: GraphEdge[]\n  /** Doc node ids in dependency-first create order. */\n  order: string[]\n  /** Fields deferred to break cycles (empty when the graph is acyclic). */\n  deferred: DeferredField[]\n}\n\n/** Whether a top-level field is required (so its refs can't be deferred). Defaults to treating every\n *  field as required — i.e. no field is deferrable, so any cycle is a hard error (the strict default).\n *  The engine passes a real lookup (from the live config) to enable optional-field cycle breaking. */\nexport type RequiredLookup = (collection: string, field: string) => boolean\n\n/** Collection slug portion of a `collection:_key` node id (slugs never contain `:`). */\nconst collectionOf = (nodeId: string): string => nodeId.slice(0, nodeId.indexOf(':'))\n\n/**\n * Build the dependency graph: doc/global nodes, edges from each doc/global to the docs it\n * references, and the topologically sorted doc create order. When a `ref` cycle exists, an optional\n * field on one edge of the cycle is **deferred** (its refs set in a second pass) to break it; a cycle\n * with no optional field to break is a hard error. Pass `isRequired` to enable this — without it every\n * field is treated as required, so any cycle throws.\n */\nexport function buildGraph(model: BuiltModel, opts: { isRequired?: RequiredLookup } = {}): SeedGraph {\n  const isRequired = opts.isRequired ?? (() => true)\n  const nodes: GraphNode[] = []\n  const edges: GraphEdge[] = []\n  const docIds = new Set<string>()\n  // Per doc: field name → the doc nodes it references (only refs that land on another seeded doc).\n  const fieldTargets = new Map<string, Map<string, Set<string>>>()\n\n  for (const coll of model.collections) {\n    for (const rec of coll.records) {\n      const id = docNodeId(coll.slug, rec.key)\n      docIds.add(id)\n      fieldTargets.set(id, new Map())\n      nodes.push({ id, type: 'doc', label: `${coll.slug}:${rec.key}`, collection: coll.slug, key: rec.key })\n    }\n  }\n\n  // Record edges per top-level field so a cycle can be broken at a specific (doc, field). `track`\n  // is false for globals — they're never part of the doc create order (updated after every doc).\n  const recordRefs = (fromId: string, data: Record<string, unknown>, track: boolean) => {\n    for (const [field, value] of Object.entries(data)) {\n      for (const token of collectTokens(value)) {\n        const to = docNodeId(token.collection, token.key)\n        edges.push({ from: fromId, to })\n        if (!track || !docIds.has(to)) continue\n        const byField = fieldTargets.get(fromId)\n        if (!byField) continue\n        let targets = byField.get(field)\n        if (!targets) {\n          targets = new Set()\n          byField.set(field, targets)\n        }\n        targets.add(to)\n      }\n    }\n  }\n\n  for (const coll of model.collections) for (const rec of coll.records) recordRefs(docNodeId(coll.slug, rec.key), rec.data, true)\n  for (const g of model.globals) {\n    const id = `global:${g.slug}`\n    nodes.push({ id, type: 'global', label: g.slug, slug: g.slug })\n    recordRefs(id, g.data, false)\n  }\n\n  const { order, deferred } = planOrder(docIds, fieldTargets, isRequired)\n  return { nodes, edges, order, deferred }\n}\n\n/** Break cycles by deferring optional fields, then depth-first topo-sort the resulting acyclic graph. */\nfunction planOrder(\n  docIds: Set<string>,\n  fieldTargets: Map<string, Map<string, Set<string>>>,\n  isRequired: RequiredLookup,\n): { order: string[]; deferred: DeferredField[] } {\n  // dependency adjacency (dependent → dependencies), mutated as cycles are broken\n  const deps = new Map<string, Set<string>>()\n  for (const id of docIds) deps.set(id, new Set())\n  for (const [node, byField] of fieldTargets) {\n    for (const targets of byField.values()) for (const to of targets) deps.get(node)?.add(to)\n  }\n\n  const deferred: DeferredField[] = []\n  const seen = new Set<string>()\n  for (let cycle = findCycle(docIds, deps); cycle !== null; cycle = findCycle(docIds, deps)) {\n    if (!breakCycle(cycle, fieldTargets, deps, isRequired, deferred, seen)) {\n      throw new Error(\n        `[payload-seed] dependency cycle detected: ${cycle.join(' -> ')} - every ref in the cycle is on a required field; make one optional to break it.`,\n      )\n    }\n  }\n  return { order: topoSortDocs(docIds, deps), deferred }\n}\n\n/**\n * Break one edge of a detected cycle by deferring an **optional** field. Walks the cycle's edges and\n * defers the first `(from, field)` whose field is optional and references the next node — removing all\n * of that field's edges from the graph. Returns false when no edge in the cycle is breakable.\n */\nfunction breakCycle(\n  cycle: string[],\n  fieldTargets: Map<string, Map<string, Set<string>>>,\n  deps: Map<string, Set<string>>,\n  isRequired: RequiredLookup,\n  deferred: DeferredField[],\n  seen: Set<string>,\n): boolean {\n  for (let i = 0; i < cycle.length - 1; i++) {\n    const from = cycle[i]\n    const to = cycle[i + 1]\n    if (from === undefined || to === undefined) continue\n    const byField = fieldTargets.get(from)\n    if (!byField) continue\n    for (const [field, targets] of byField) {\n      if (!targets.has(to) || isRequired(collectionOf(from), field)) continue\n      // Defer the whole field: remove every edge it contributes (safe — the second pass sets it\n      // once all docs exist), which breaks this cycle and any other routed through the same field.\n      for (const t of targets) deps.get(from)?.delete(t)\n      const key = `${from}\u0000${field}`\n      if (!seen.has(key)) {\n        seen.add(key)\n        deferred.push({ node: from, field })\n      }\n      return true\n    }\n  }\n  return false\n}\n\n/** Find one dependency cycle as `[start, …, start]`, or null if the graph is acyclic. */\nfunction findCycle(docIds: Set<string>, deps: Map<string, Set<string>>): string[] | null {\n  const state = new Map<string, 'visiting' | 'done'>()\n  const stack: string[] = []\n  let cycle: string[] | null = null\n\n  const visit = (id: string) => {\n    if (cycle) return\n    const s = state.get(id)\n    if (s === 'done') return\n    if (s === 'visiting') {\n      cycle = [...stack.slice(stack.indexOf(id)), id]\n      return\n    }\n    state.set(id, 'visiting')\n    stack.push(id)\n    for (const dep of deps.get(id) ?? []) {\n      if (!docIds.has(dep)) continue\n      visit(dep)\n      if (cycle) break\n    }\n    stack.pop()\n    state.set(id, 'done')\n  }\n\n  for (const id of docIds) {\n    if (cycle) break\n    visit(id)\n  }\n  return cycle\n}\n\n/** Depth-first topological sort (dependencies first). Throws on a cycle — a safety assertion, since\n *  `planOrder` breaks every cycle before calling this. */\nfunction topoSortDocs(docIds: Set<string>, deps: Map<string, Set<string>>): string[] {\n  const order: string[] = []\n  const state = new Map<string, 'visiting' | 'done'>()\n  const stack: string[] = []\n\n  const visit = (id: string) => {\n    const s = state.get(id)\n    if (s === 'done') return\n    if (s === 'visiting') {\n      const cycle = [...stack.slice(stack.indexOf(id)), id].join(' -> ')\n      throw new Error(`[payload-seed] dependency cycle detected: ${cycle}`)\n    }\n    state.set(id, 'visiting')\n    stack.push(id)\n    for (const dep of deps.get(id) ?? []) {\n      if (!docIds.has(dep)) continue\n      visit(dep)\n    }\n    stack.pop()\n    state.set(id, 'done')\n    order.push(id)\n  }\n\n  for (const id of docIds) visit(id)\n  return order\n}\n"],"names":["collectTokens","docNodeId","collectionOf","nodeId","slice","indexOf","buildGraph","model","opts","isRequired","nodes","edges","docIds","Set","fieldTargets","Map","coll","collections","rec","records","id","slug","key","add","set","push","type","label","collection","recordRefs","fromId","data","track","field","value","Object","entries","token","to","from","has","byField","get","targets","g","globals","order","deferred","planOrder","deps","node","values","seen","cycle","findCycle","breakCycle","Error","join","topoSortDocs","i","length","undefined","t","delete","state","stack","visit","s","dep","pop"],"mappings":"AACA,SAASA,aAAa,EAAEC,SAAS,QAAQ,cAAU;AAwDnD,sFAAsF,GACtF,MAAMC,eAAe,CAACC,SAA2BA,OAAOC,KAAK,CAAC,GAAGD,OAAOE,OAAO,CAAC;AAEhF;;;;;;CAMC,GACD,OAAO,SAASC,WAAWC,KAAiB,EAAEC,OAAwC,CAAC,CAAC;IACtF,MAAMC,aAAaD,KAAKC,UAAU,IAAK,CAAA,IAAM,IAAG;IAChD,MAAMC,QAAqB,EAAE;IAC7B,MAAMC,QAAqB,EAAE;IAC7B,MAAMC,SAAS,IAAIC;IACnB,iGAAiG;IACjG,MAAMC,eAAe,IAAIC;IAEzB,KAAK,MAAMC,QAAQT,MAAMU,WAAW,CAAE;QACpC,KAAK,MAAMC,OAAOF,KAAKG,OAAO,CAAE;YAC9B,MAAMC,KAAKnB,UAAUe,KAAKK,IAAI,EAAEH,IAAII,GAAG;YACvCV,OAAOW,GAAG,CAACH;YACXN,aAAaU,GAAG,CAACJ,IAAI,IAAIL;YACzBL,MAAMe,IAAI,CAAC;gBAAEL;gBAAIM,MAAM;gBAAOC,OAAO,GAAGX,KAAKK,IAAI,CAAC,CAAC,EAAEH,IAAII,GAAG,EAAE;gBAAEM,YAAYZ,KAAKK,IAAI;gBAAEC,KAAKJ,IAAII,GAAG;YAAC;QACtG;IACF;IAEA,gGAAgG;IAChG,+FAA+F;IAC/F,MAAMO,aAAa,CAACC,QAAgBC,MAA+BC;QACjE,KAAK,MAAM,CAACC,OAAOC,MAAM,IAAIC,OAAOC,OAAO,CAACL,MAAO;YACjD,KAAK,MAAMM,SAASrC,cAAckC,OAAQ;gBACxC,MAAMI,KAAKrC,UAAUoC,MAAMT,UAAU,EAAES,MAAMf,GAAG;gBAChDX,MAAMc,IAAI,CAAC;oBAAEc,MAAMT;oBAAQQ;gBAAG;gBAC9B,IAAI,CAACN,SAAS,CAACpB,OAAO4B,GAAG,CAACF,KAAK;gBAC/B,MAAMG,UAAU3B,aAAa4B,GAAG,CAACZ;gBACjC,IAAI,CAACW,SAAS;gBACd,IAAIE,UAAUF,QAAQC,GAAG,CAACT;gBAC1B,IAAI,CAACU,SAAS;oBACZA,UAAU,IAAI9B;oBACd4B,QAAQjB,GAAG,CAACS,OAAOU;gBACrB;gBACAA,QAAQpB,GAAG,CAACe;YACd;QACF;IACF;IAEA,KAAK,MAAMtB,QAAQT,MAAMU,WAAW,CAAE,KAAK,MAAMC,OAAOF,KAAKG,OAAO,CAAEU,WAAW5B,UAAUe,KAAKK,IAAI,EAAEH,IAAII,GAAG,GAAGJ,IAAIa,IAAI,EAAE;IAC1H,KAAK,MAAMa,KAAKrC,MAAMsC,OAAO,CAAE;QAC7B,MAAMzB,KAAK,CAAC,OAAO,EAAEwB,EAAEvB,IAAI,EAAE;QAC7BX,MAAMe,IAAI,CAAC;YAAEL;YAAIM,MAAM;YAAUC,OAAOiB,EAAEvB,IAAI;YAAEA,MAAMuB,EAAEvB,IAAI;QAAC;QAC7DQ,WAAWT,IAAIwB,EAAEb,IAAI,EAAE;IACzB;IAEA,MAAM,EAAEe,KAAK,EAAEC,QAAQ,EAAE,GAAGC,UAAUpC,QAAQE,cAAcL;IAC5D,OAAO;QAAEC;QAAOC;QAAOmC;QAAOC;IAAS;AACzC;AAEA,uGAAuG,GACvG,SAASC,UACPpC,MAAmB,EACnBE,YAAmD,EACnDL,UAA0B;IAE1B,gFAAgF;IAChF,MAAMwC,OAAO,IAAIlC;IACjB,KAAK,MAAMK,MAAMR,OAAQqC,KAAKzB,GAAG,CAACJ,IAAI,IAAIP;IAC1C,KAAK,MAAM,CAACqC,MAAMT,QAAQ,IAAI3B,aAAc;QAC1C,KAAK,MAAM6B,WAAWF,QAAQU,MAAM,GAAI,KAAK,MAAMb,MAAMK,QAASM,KAAKP,GAAG,CAACQ,OAAO3B,IAAIe;IACxF;IAEA,MAAMS,WAA4B,EAAE;IACpC,MAAMK,OAAO,IAAIvC;IACjB,IAAK,IAAIwC,QAAQC,UAAU1C,QAAQqC,OAAOI,UAAU,MAAMA,QAAQC,UAAU1C,QAAQqC,MAAO;QACzF,IAAI,CAACM,WAAWF,OAAOvC,cAAcmC,MAAMxC,YAAYsC,UAAUK,OAAO;YACtE,MAAM,IAAII,MACR,CAAC,0CAA0C,EAAEH,MAAMI,IAAI,CAAC,QAAQ,gFAAgF,CAAC;QAErJ;IACF;IACA,OAAO;QAAEX,OAAOY,aAAa9C,QAAQqC;QAAOF;IAAS;AACvD;AAEA;;;;CAIC,GACD,SAASQ,WACPF,KAAe,EACfvC,YAAmD,EACnDmC,IAA8B,EAC9BxC,UAA0B,EAC1BsC,QAAyB,EACzBK,IAAiB;IAEjB,IAAK,IAAIO,IAAI,GAAGA,IAAIN,MAAMO,MAAM,GAAG,GAAGD,IAAK;QACzC,MAAMpB,OAAOc,KAAK,CAACM,EAAE;QACrB,MAAMrB,KAAKe,KAAK,CAACM,IAAI,EAAE;QACvB,IAAIpB,SAASsB,aAAavB,OAAOuB,WAAW;QAC5C,MAAMpB,UAAU3B,aAAa4B,GAAG,CAACH;QACjC,IAAI,CAACE,SAAS;QACd,KAAK,MAAM,CAACR,OAAOU,QAAQ,IAAIF,QAAS;YACtC,IAAI,CAACE,QAAQH,GAAG,CAACF,OAAO7B,WAAWP,aAAaqC,OAAON,QAAQ;YAC/D,0FAA0F;YAC1F,6FAA6F;YAC7F,KAAK,MAAM6B,KAAKnB,QAASM,KAAKP,GAAG,CAACH,OAAOwB,OAAOD;YAChD,MAAMxC,MAAM,GAAGiB,KAAK,CAAC,EAAEN,OAAO;YAC9B,IAAI,CAACmB,KAAKZ,GAAG,CAAClB,MAAM;gBAClB8B,KAAK7B,GAAG,CAACD;gBACTyB,SAAStB,IAAI,CAAC;oBAAEyB,MAAMX;oBAAMN;gBAAM;YACpC;YACA,OAAO;QACT;IACF;IACA,OAAO;AACT;AAEA,uFAAuF,GACvF,SAASqB,UAAU1C,MAAmB,EAAEqC,IAA8B;IACpE,MAAMe,QAAQ,IAAIjD;IAClB,MAAMkD,QAAkB,EAAE;IAC1B,IAAIZ,QAAyB;IAE7B,MAAMa,QAAQ,CAAC9C;QACb,IAAIiC,OAAO;QACX,MAAMc,IAAIH,MAAMtB,GAAG,CAACtB;QACpB,IAAI+C,MAAM,QAAQ;QAClB,IAAIA,MAAM,YAAY;YACpBd,QAAQ;mBAAIY,MAAM7D,KAAK,CAAC6D,MAAM5D,OAAO,CAACe;gBAAMA;aAAG;YAC/C;QACF;QACA4C,MAAMxC,GAAG,CAACJ,IAAI;QACd6C,MAAMxC,IAAI,CAACL;QACX,KAAK,MAAMgD,OAAOnB,KAAKP,GAAG,CAACtB,OAAO,EAAE,CAAE;YACpC,IAAI,CAACR,OAAO4B,GAAG,CAAC4B,MAAM;YACtBF,MAAME;YACN,IAAIf,OAAO;QACb;QACAY,MAAMI,GAAG;QACTL,MAAMxC,GAAG,CAACJ,IAAI;IAChB;IAEA,KAAK,MAAMA,MAAMR,OAAQ;QACvB,IAAIyC,OAAO;QACXa,MAAM9C;IACR;IACA,OAAOiC;AACT;AAEA;wDACwD,GACxD,SAASK,aAAa9C,MAAmB,EAAEqC,IAA8B;IACvE,MAAMH,QAAkB,EAAE;IAC1B,MAAMkB,QAAQ,IAAIjD;IAClB,MAAMkD,QAAkB,EAAE;IAE1B,MAAMC,QAAQ,CAAC9C;QACb,MAAM+C,IAAIH,MAAMtB,GAAG,CAACtB;QACpB,IAAI+C,MAAM,QAAQ;QAClB,IAAIA,MAAM,YAAY;YACpB,MAAMd,QAAQ;mBAAIY,MAAM7D,KAAK,CAAC6D,MAAM5D,OAAO,CAACe;gBAAMA;aAAG,CAACqC,IAAI,CAAC;YAC3D,MAAM,IAAID,MAAM,CAAC,0CAA0C,EAAEH,OAAO;QACtE;QACAW,MAAMxC,GAAG,CAACJ,IAAI;QACd6C,MAAMxC,IAAI,CAACL;QACX,KAAK,MAAMgD,OAAOnB,KAAKP,GAAG,CAACtB,OAAO,EAAE,CAAE;YACpC,IAAI,CAACR,OAAO4B,GAAG,CAAC4B,MAAM;YACtBF,MAAME;QACR;QACAH,MAAMI,GAAG;QACTL,MAAMxC,GAAG,CAACJ,IAAI;QACd0B,MAAMrB,IAAI,CAACL;IACb;IAEA,KAAK,MAAMA,MAAMR,OAAQsD,MAAM9C;IAC/B,OAAO0B;AACT"}