@foldcn/registry 0.0.1

package/dist/componentsConfig/componentsConfig.d.ts

@@ -0,0 +1,32 @@
+import { Schema } from 'effect';
+/**
+ * Directory aliases for where copied files land in a consumer project,
+ * relative to the project root.
+ */
+export declare const Aliases: Schema.Struct<{
+    readonly ui: Schema.String;
+    readonly lib: Schema.String;
+}>;
+export type Aliases = typeof Aliases.Type;
+/**
+ * The `components.json` a consumer project carries. `registries` maps
+ * `@namespace` keys to URL templates containing `{name}`.
+ */
+export declare const Config: Schema.Struct<{
+    readonly $schema: Schema.optionalKey<Schema.String>;
+    readonly css: Schema.String;
+    readonly baseColor: Schema.String;
+    readonly aliases: Schema.Struct<{
+        readonly ui: Schema.String;
+        readonly lib: Schema.String;
+    }>;
+    readonly registries: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export type Config = typeof Config.Type;
+/** Default stylesheet location, matching create-foldkit-app's template. */
+export declare const defaultCss = "src/styles.css";
+/** Default base color shipped by the foldcn registry. */
+export declare const defaultBaseColor = "neutral";
+/** Default alias directories for copied files. */
+export declare const defaultAliases: Aliases;
+//# sourceMappingURL=componentsConfig.d.ts.map

package/dist/componentsConfig/componentsConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentsConfig.d.ts","sourceRoot":"","sources":["../../src/componentsConfig/componentsConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;GAGG;AACH,eAAO,MAAM,OAAO;;;EAG0C,CAAA;AAC9D,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;EAM0C,CAAA;AAC7D,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,2EAA2E;AAC3E,eAAO,MAAM,UAAU,mBAAmB,CAAA;AAE1C,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,YAAY,CAAA;AAEzC,kDAAkD;AAClD,eAAO,MAAM,cAAc,EAAE,OAG5B,CAAA"}

package/dist/componentsConfig/componentsConfig.js

@@ -0,0 +1,29 @@
+import { Schema } from 'effect';
+/**
+ * Directory aliases for where copied files land in a consumer project,
+ * relative to the project root.
+ */
+export const Aliases = Schema.Struct({
+    ui: Schema.String,
+    lib: Schema.String,
+}).annotate({ identifier: 'Foldcn.ComponentsConfig.Aliases' });
+/**
+ * The `components.json` a consumer project carries. `registries` maps
+ * `@namespace` keys to URL templates containing `{name}`.
+ */
+export const Config = Schema.Struct({
+    $schema: Schema.optionalKey(Schema.String),
+    css: Schema.String,
+    baseColor: Schema.String,
+    aliases: Aliases,
+    registries: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+}).annotate({ identifier: 'Foldcn.ComponentsConfig.Config' });
+/** Default stylesheet location, matching create-foldkit-app's template. */
+export const defaultCss = 'src/styles.css';
+/** Default base color shipped by the foldcn registry. */
+export const defaultBaseColor = 'neutral';
+/** Default alias directories for copied files. */
+export const defaultAliases = {
+    ui: 'src/components/ui',
+    lib: 'src/lib',
+};

package/dist/componentsConfig/index.d.ts

@@ -0,0 +1,2 @@
+export * from './componentsConfig';
+//# sourceMappingURL=index.d.ts.map

package/dist/componentsConfig/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/componentsConfig/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA"}

package/dist/componentsConfig/index.js

@@ -0,0 +1 @@
+export * from './componentsConfig';

package/dist/cssMerge/cssMerge.d.ts

@@ -0,0 +1,25 @@
+import { Effect, Schema } from 'effect';
+import type { Css, CssVars } from '../registry';
+declare const CssParseError_base: Schema.Class<CssParseError, Schema.TaggedStruct<"CssParseError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when the consumer stylesheet cannot be parsed or transformed. */
+export declare class CssParseError extends CssParseError_base {
+}
+/** Options for {@link merge}. */
+export interface MergeOptions {
+    readonly css: string;
+    readonly cssVars?: CssVars;
+    readonly extraCss?: Css;
+    readonly isOverwriting?: boolean;
+}
+/**
+ * Merges registry cssVars and css into a Tailwind v4 stylesheet. Upserts the
+ * dark custom variant, `:root` and `.dark` variable blocks, the `@theme
+ * inline` token mapping, and any extra rules. Idempotent: re-running with the
+ * same inputs never duplicates blocks, and user content outside touched
+ * declarations is preserved.
+ */
+export declare const merge: (options: MergeOptions) => Effect.Effect<string, CssParseError>;
+export {};
+//# sourceMappingURL=cssMerge.d.ts.map

package/dist/cssMerge/cssMerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cssMerge.d.ts","sourceRoot":"","sources":["../../src/cssMerge/cssMerge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAIvC,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;;;;AAE/C,2EAA2E;AAC3E,qBAAa,aAAc,SAAQ,kBAEjC;CAAG;AAEL,iCAAiC;AACjC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CACjC;AAWD;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAAI,SAAS,YAAY,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAI7E,CAAA"}

package/dist/cssMerge/cssMerge.js

@@ -0,0 +1,297 @@
+import { Effect, Schema } from 'effect';
+import postcss from 'postcss';
+/** Raised when the consumer stylesheet cannot be parsed or transformed. */
+export class CssParseError extends Schema.TaggedErrorClass()('CssParseError', {
+    message: Schema.String,
+}) {
+}
+const darkVariantParams = '(&:is(.dark *))';
+const radiusScale = {
+    '--radius-sm': 'calc(var(--radius) - 4px)',
+    '--radius-md': 'calc(var(--radius) - 2px)',
+    '--radius-lg': 'var(--radius)',
+    '--radius-xl': 'calc(var(--radius) + 4px)',
+};
+/**
+ * Merges registry cssVars and css into a Tailwind v4 stylesheet. Upserts the
+ * dark custom variant, `:root` and `.dark` variable blocks, the `@theme
+ * inline` token mapping, and any extra rules. Idempotent: re-running with the
+ * same inputs never duplicates blocks, and user content outside touched
+ * declarations is preserved.
+ */
+export const merge = (options) => Effect.try({
+    try: () => mergeSync(options),
+    catch: (error) => new CssParseError({ message: String(error) }),
+});
+const mergeSync = (options) => {
+    const root = postcss.parse(options.css);
+    const isOverwriting = options.isOverwriting ?? false;
+    const hasCssVars = options.cssVars !== undefined &&
+        Object.values(options.cssVars).some((vars) => vars !== undefined && Object.keys(vars).length > 0);
+    if (hasCssVars && options.cssVars !== undefined) {
+        ensureDarkVariant(root);
+        applyCssVars(root, options.cssVars, isOverwriting);
+        applyThemeMapping(root, options.cssVars);
+    }
+    if (options.extraCss !== undefined) {
+        applyExtraCss(root, options.extraCss);
+    }
+    let output = root.toResult().css;
+    output = output.replace(/(\n\s*\n)+/g, '\n\n');
+    return `${output.trimEnd()}\n`;
+};
+const isAtRule = (node, name) => node.type === 'atrule' && node.name === name;
+const findAtRule = (root, name, params) => root.nodes.find((node) => isAtRule(node, name) && (params === undefined || node.params === params));
+const lastAtRule = (root, name) => {
+    const matches = root.nodes.filter((node) => isAtRule(node, name));
+    return matches.at(-1);
+};
+const ensureDarkVariant = (root) => {
+    const existing = root.nodes.find((node) => isAtRule(node, 'custom-variant') && node.params.startsWith('dark'));
+    if (existing !== undefined) {
+        return;
+    }
+    const variantNode = postcss.atRule({
+        name: 'custom-variant',
+        params: `dark ${darkVariantParams}`,
+        raws: { semicolon: true, before: '\n\n' },
+    });
+    const lastImport = lastAtRule(root, 'import');
+    if (lastImport !== undefined) {
+        root.insertAfter(lastImport, variantNode);
+        return;
+    }
+    const firstNode = root.nodes.at(0);
+    if (firstNode !== undefined) {
+        root.insertAfter(firstNode, variantNode);
+        return;
+    }
+    root.append(variantNode);
+};
+const upsertThemeNode = (root) => {
+    const existing = findAtRule(root, 'theme', 'inline');
+    if (existing !== undefined) {
+        return existing;
+    }
+    const themeNode = postcss.atRule({
+        name: 'theme',
+        params: 'inline',
+        nodes: [],
+        raws: { semicolon: true, between: ' ', before: '\n\n' },
+    });
+    root.append(themeNode);
+    return themeNode;
+};
+const upsertRule = (root, selector) => {
+    const existing = root.nodes.find((node) => node.type === 'rule' && node.selector === selector);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const ruleNode = postcss.rule({
+        selector,
+        nodes: [],
+        raws: { semicolon: true, between: ' ', before: '\n\n' },
+    });
+    root.append(ruleNode);
+    return ruleNode;
+};
+const upsertDeclaration = (container, prop, value, isOverwriting) => {
+    const existing = container.nodes?.find((node) => node.type === 'decl' && node.prop === prop);
+    const declaration = postcss.decl({ prop, value, raws: { semicolon: true, before: '\n  ' } });
+    if (existing !== undefined) {
+        if (isOverwriting && existing.value !== value) {
+            existing.replaceWith(declaration);
+        }
+        return;
+    }
+    container.append(declaration);
+};
+const normalizeProp = (name) => `--${name.replace(/^--/, '')}`;
+const applyCssVars = (root, cssVars, isOverwriting) => {
+    if (cssVars.theme !== undefined && Object.keys(cssVars.theme).length > 0) {
+        const themeNode = upsertThemeNode(root);
+        for (const [name, value] of Object.entries(cssVars.theme)) {
+            upsertDeclaration(themeNode, normalizeProp(name), value, isOverwriting);
+        }
+    }
+    const selectorVars = [
+        [':root', cssVars.light],
+        ['.dark', cssVars.dark],
+    ];
+    for (const [selector, vars] of selectorVars) {
+        if (vars === undefined || Object.keys(vars).length === 0) {
+            continue;
+        }
+        const ruleNode = upsertRule(root, selector);
+        for (const [name, value] of Object.entries(vars)) {
+            upsertDeclaration(ruleNode, normalizeProp(name), value, isOverwriting);
+        }
+    }
+};
+const isColorValue = (value) => value.startsWith('hsl') ||
+    value.startsWith('rgb') ||
+    value.startsWith('#') ||
+    value.startsWith('oklch') ||
+    value.includes('--color-');
+const applyThemeMapping = (root, cssVars) => {
+    const scopes = [cssVars.light, cssVars.dark].filter((vars) => vars !== undefined);
+    const names = Array.from(new Set(scopes.flatMap((vars) => Object.keys(vars))));
+    if (names.length === 0) {
+        return;
+    }
+    const themeNode = upsertThemeNode(root);
+    for (const name of names) {
+        const value = scopes.map((vars) => vars[name]).find((found) => found !== undefined);
+        if (value === undefined) {
+            continue;
+        }
+        if (name === 'radius') {
+            for (const [prop, radiusValue] of Object.entries(radiusScale)) {
+                upsertDeclaration(themeNode, prop, radiusValue, false);
+            }
+            continue;
+        }
+        const bare = name.replace(/^--/, '');
+        const prop = isColorValue(value) ? `--color-${bare}` : `--${bare}`;
+        upsertDeclaration(themeNode, prop, `var(--${bare})`, false);
+    }
+};
+const atRuleHeader = (selector) => {
+    const match = selector.match(/^@([a-zA-Z-]+)\s*(.*)$/);
+    if (match === null) {
+        return undefined;
+    }
+    const name = match[1];
+    const params = match[2];
+    if (name === undefined) {
+        return undefined;
+    }
+    return [name, params ?? ''];
+};
+const applyExtraCss = (root, extraCss) => {
+    for (const [selector, value] of Object.entries(extraCss)) {
+        const header = atRuleHeader(selector);
+        if (header !== undefined) {
+            applyAtRule(root, header[0], header[1], value);
+            continue;
+        }
+        if (typeof value === 'object') {
+            const ruleNode = upsertRule(root, selector);
+            applyBody(ruleNode, value);
+        }
+    }
+};
+const applyAtRule = (root, name, params, value) => {
+    if (name === 'import' || name === 'plugin' || name === 'custom-variant') {
+        const exists = root.nodes.some((node) => isAtRule(node, name) && node.params === params);
+        if (!exists) {
+            const atRuleNode = postcss.atRule({ name, params, raws: { semicolon: true, before: '\n' } });
+            const lastImport = lastAtRule(root, 'import');
+            if (lastImport !== undefined) {
+                root.insertAfter(lastImport, atRuleNode);
+            }
+            else {
+                root.prepend(atRuleNode);
+            }
+        }
+        return;
+    }
+    if (typeof value === 'object' && Object.keys(value).length === 0) {
+        const exists = root.nodes.some((node) => isAtRule(node, name) && node.params === params);
+        if (!exists) {
+            root.append(postcss.atRule({ name, params, raws: { semicolon: true, before: '\n\n' } }));
+        }
+        return;
+    }
+    if (name === 'keyframes') {
+        const themeNode = upsertThemeNode(root);
+        const existing = themeNode.nodes?.find((node) => node.type === 'atrule' && isAtRule(node, 'keyframes') && node.params === params);
+        const keyframesNode = postcss.atRule({
+            name,
+            params,
+            nodes: [],
+            raws: { semicolon: true, between: ' ', before: '\n  ' },
+        });
+        if (existing !== undefined) {
+            existing.replaceWith(keyframesNode);
+        }
+        else {
+            themeNode.append(keyframesNode);
+        }
+        if (typeof value === 'object') {
+            applyBody(keyframesNode, value);
+        }
+        return;
+    }
+    const existing = root.nodes.find((node) => isAtRule(node, name) && node.params === params);
+    const atRuleNode = existing ??
+        (() => {
+            const created = postcss.atRule({
+                name,
+                params,
+                nodes: [],
+                raws: { semicolon: true, between: ' ', before: '\n\n' },
+            });
+            root.append(created);
+            return created;
+        })();
+    if (typeof value === 'object') {
+        applyBody(atRuleNode, value);
+    }
+};
+const applyBody = (container, body) => {
+    for (const [key, value] of Object.entries(body)) {
+        if (typeof value === 'string' && key.startsWith('@')) {
+            const header = atRuleHeader(key);
+            if (header !== undefined) {
+                const [name, params] = header;
+                const exists = container.nodes?.some((node) => node.type === 'atrule' && node.name === name && node.params === params);
+                if (exists !== true) {
+                    container.append(postcss.atRule({ name, params, raws: { semicolon: true, before: '\n  ' } }));
+                }
+            }
+            continue;
+        }
+        if (typeof value === 'string') {
+            upsertDeclaration(container, key, value, true);
+            continue;
+        }
+        const header = atRuleHeader(key);
+        if (header !== undefined) {
+            const [name, params] = header;
+            if (typeof value === 'object' && Object.keys(value).length === 0) {
+                const exists = container.nodes?.some((node) => node.type === 'atrule' && node.name === name && node.params === params);
+                if (exists !== true) {
+                    container.append(postcss.atRule({ name, params, raws: { semicolon: true, before: '\n  ' } }));
+                }
+                continue;
+            }
+            const existing = container.nodes?.find((node) => node.type === 'atrule' && node.name === name && node.params === params);
+            const nested = existing ??
+                (() => {
+                    const created = postcss.atRule({
+                        name,
+                        params,
+                        nodes: [],
+                        raws: { semicolon: true, between: ' ', before: '\n  ' },
+                    });
+                    container.append(created);
+                    return created;
+                })();
+            applyBody(nested, value);
+            continue;
+        }
+        const existing = container.nodes?.find((node) => node.type === 'rule' && node.selector === key);
+        const nested = existing ??
+            (() => {
+                const created = postcss.rule({
+                    selector: key,
+                    nodes: [],
+                    raws: { semicolon: true, between: ' ', before: '\n  ' },
+                });
+                container.append(created);
+                return created;
+            })();
+        applyBody(nested, value);
+    }
+};

package/dist/cssMerge/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cssMerge';
+//# sourceMappingURL=index.d.ts.map

package/dist/cssMerge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cssMerge/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/cssMerge/index.js

@@ -0,0 +1 @@
+export * from './cssMerge';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as Registry from './registry';
+export * as ComponentsConfig from './componentsConfig';
+export * as ResolveTree from './resolveTree';
+export * as CssMerge from './cssMerge';
+//# 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":"AAAA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,gBAAgB,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * as Registry from './registry';
+export * as ComponentsConfig from './componentsConfig';
+export * as ResolveTree from './resolveTree';
+export * as CssMerge from './cssMerge';

package/dist/registry/index.d.ts

@@ -0,0 +1,2 @@
+export * from './registry';
+//# sourceMappingURL=index.d.ts.map

package/dist/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/registry/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/registry/index.js

@@ -0,0 +1 @@
+export * from './registry';

package/dist/registry/registry.d.ts

@@ -0,0 +1,101 @@
+import { Schema } from 'effect';
+/**
+ * The kind of a registry item or file. Mirrors shadcn's registry item types,
+ * trimmed to what FoldKit projects need.
+ */
+export declare const ItemType: Schema.Literals<readonly ["registry:ui", "registry:lib", "registry:block", "registry:theme", "registry:file", "registry:example"]>;
+export type ItemType = typeof ItemType.Type;
+/**
+ * A single distributable file within a registry item. `content` is inlined by
+ * `foldcn build`; `target` is required for `registry:file` items and resolved
+ * against the consumer project root.
+ */
+export declare const ItemFile: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly type: Schema.Literals<readonly ["registry:ui", "registry:lib", "registry:block", "registry:theme", "registry:file", "registry:example"]>;
+    readonly target: Schema.optionalKey<Schema.String>;
+    readonly content: Schema.optionalKey<Schema.String>;
+}>;
+export type ItemFile = typeof ItemFile.Type;
+/**
+ * CSS variables contributed by an item, merged into the consumer stylesheet.
+ * `theme` lands in `@theme inline`, `light` in `:root`, `dark` in `.dark`.
+ */
+export declare const CssVars: Schema.Struct<{
+    readonly theme: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly light: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly dark: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export type CssVars = typeof CssVars.Type;
+/**
+ * Arbitrary nested CSS contributed by an item, keyed by selector or at-rule.
+ * String values are declarations, nested records are rules.
+ */
+export interface Css {
+    readonly [selector: string]: string | Css;
+}
+export declare const Css: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.suspend<Schema.Codec<Css, Css, never, never>>]>>;
+/**
+ * A registry item: one distributable unit (component, lib file, theme, block,
+ * or arbitrary file) with its npm and registry dependencies.
+ */
+export declare const Item: Schema.Struct<{
+    readonly $schema: Schema.optionalKey<Schema.String>;
+    readonly name: Schema.String;
+    readonly type: Schema.Literals<readonly ["registry:ui", "registry:lib", "registry:block", "registry:theme", "registry:file", "registry:example"]>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly dependencies: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly devDependencies: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly registryDependencies: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly files: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly type: Schema.Literals<readonly ["registry:ui", "registry:lib", "registry:block", "registry:theme", "registry:file", "registry:example"]>;
+        readonly target: Schema.optionalKey<Schema.String>;
+        readonly content: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly cssVars: Schema.optionalKey<Schema.Struct<{
+        readonly theme: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly light: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly dark: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    }>>;
+    readonly css: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.suspend<Schema.Codec<Css, Css, never, never>>]>>>;
+    readonly docs: Schema.optionalKey<Schema.String>;
+    readonly categories: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+export type Item = typeof Item.Type;
+/**
+ * The registry manifest (`registry.json`): the list of items a registry
+ * publishes, built into per-item JSON by `foldcn build`.
+ */
+export declare const Manifest: Schema.Struct<{
+    readonly $schema: Schema.optionalKey<Schema.String>;
+    readonly name: Schema.String;
+    readonly homepage: Schema.String;
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly $schema: Schema.optionalKey<Schema.String>;
+        readonly name: Schema.String;
+        readonly type: Schema.Literals<readonly ["registry:ui", "registry:lib", "registry:block", "registry:theme", "registry:file", "registry:example"]>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly dependencies: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly devDependencies: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly registryDependencies: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly files: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly type: Schema.Literals<readonly ["registry:ui", "registry:lib", "registry:block", "registry:theme", "registry:file", "registry:example"]>;
+            readonly target: Schema.optionalKey<Schema.String>;
+            readonly content: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly cssVars: Schema.optionalKey<Schema.Struct<{
+            readonly theme: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly light: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly dark: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        }>>;
+        readonly css: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.suspend<Schema.Codec<Css, Css, never, never>>]>>>;
+        readonly docs: Schema.optionalKey<Schema.String>;
+        readonly categories: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>;
+}>;
+export type Manifest = typeof Manifest.Type;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;GAGG;AACH,eAAO,MAAM,QAAQ,oIAOkC,CAAA;AACvD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;EAKkC,CAAA;AACvD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;GAGG;AACH,eAAO,MAAM,OAAO;;;;EAIkC,CAAA;AACtD,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC;;;GAGG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,CAAA;CAC1C;AACD,eAAO,MAAM,GAAG,6HAGiC,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;EAckC,CAAA;AACnD,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKkC,CAAA;AACvD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA"}

package/dist/registry/registry.js

@@ -0,0 +1,63 @@
+import { Schema } from 'effect';
+/**
+ * The kind of a registry item or file. Mirrors shadcn's registry item types,
+ * trimmed to what FoldKit projects need.
+ */
+export const ItemType = Schema.Literals([
+    'registry:ui',
+    'registry:lib',
+    'registry:block',
+    'registry:theme',
+    'registry:file',
+    'registry:example',
+]).annotate({ identifier: 'Foldcn.Registry.ItemType' });
+/**
+ * A single distributable file within a registry item. `content` is inlined by
+ * `foldcn build`; `target` is required for `registry:file` items and resolved
+ * against the consumer project root.
+ */
+export const ItemFile = Schema.Struct({
+    path: Schema.String,
+    type: ItemType,
+    target: Schema.optionalKey(Schema.String),
+    content: Schema.optionalKey(Schema.String),
+}).annotate({ identifier: 'Foldcn.Registry.ItemFile' });
+/**
+ * CSS variables contributed by an item, merged into the consumer stylesheet.
+ * `theme` lands in `@theme inline`, `light` in `:root`, `dark` in `.dark`.
+ */
+export const CssVars = Schema.Struct({
+    theme: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+    light: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+    dark: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+}).annotate({ identifier: 'Foldcn.Registry.CssVars' });
+export const Css = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.suspend(() => Css)])).annotate({ identifier: 'Foldcn.Registry.Css' });
+/**
+ * A registry item: one distributable unit (component, lib file, theme, block,
+ * or arbitrary file) with its npm and registry dependencies.
+ */
+export const Item = Schema.Struct({
+    $schema: Schema.optionalKey(Schema.String),
+    name: Schema.String,
+    type: ItemType,
+    title: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+    dependencies: Schema.optionalKey(Schema.Array(Schema.String)),
+    devDependencies: Schema.optionalKey(Schema.Array(Schema.String)),
+    registryDependencies: Schema.optionalKey(Schema.Array(Schema.String)),
+    files: Schema.optionalKey(Schema.Array(ItemFile)),
+    cssVars: Schema.optionalKey(CssVars),
+    css: Schema.optionalKey(Css),
+    docs: Schema.optionalKey(Schema.String),
+    categories: Schema.optionalKey(Schema.Array(Schema.String)),
+}).annotate({ identifier: 'Foldcn.Registry.Item' });
+/**
+ * The registry manifest (`registry.json`): the list of items a registry
+ * publishes, built into per-item JSON by `foldcn build`.
+ */
+export const Manifest = Schema.Struct({
+    $schema: Schema.optionalKey(Schema.String),
+    name: Schema.String,
+    homepage: Schema.String,
+    items: Schema.Array(Item),
+}).annotate({ identifier: 'Foldcn.Registry.Manifest' });

package/dist/resolveTree/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resolveTree';
+//# sourceMappingURL=index.d.ts.map

package/dist/resolveTree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolveTree/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/resolveTree/index.js

@@ -0,0 +1 @@
+export * from './resolveTree';

package/dist/resolveTree/resolveTree.d.ts

@@ -0,0 +1,39 @@
+import { Effect, Option } from 'effect';
+import type { Css, CssVars, Item, ItemFile } from '../registry';
+/**
+ * A fetched registry item together with the canonical key it was resolved
+ * under. The key deduplicates items that different specifiers resolve to.
+ */
+export interface FetchedItem {
+    readonly key: string;
+    readonly item: Item;
+}
+/**
+ * The merged closure of a set of registry items: everything `foldcn add`
+ * needs to write files, install packages, and update the stylesheet.
+ */
+export interface ResolvedTree {
+    readonly items: ReadonlyArray<Item>;
+    readonly dependencies: ReadonlyArray<string>;
+    readonly devDependencies: ReadonlyArray<string>;
+    readonly files: ReadonlyArray<ItemFile>;
+    readonly cssVars: CssVars;
+    readonly css: Css;
+    readonly warnings: ReadonlyArray<string>;
+}
+/**
+ * Resolves the `registryDependencies` closure of the given specifiers via
+ * breadth-first traversal. `getItem` performs the actual fetch and returns a
+ * canonical key per item; cycles and diamonds are deduplicated on that key.
+ * `maybeOrigin` carries the key of the item that requested the dependency so
+ * bare names can resolve against their origin registry.
+ */
+export declare const resolve: <E, R>(rootSpecs: ReadonlyArray<string>, getItem: (spec: string, maybeOrigin: Option.Option<string>) => Effect.Effect<FetchedItem, E, R>) => Effect.Effect<ResolvedTree, E, R>;
+/**
+ * Merges an ordered list of items into a single plan. Npm dependencies are
+ * deduplicated by package name (first version-qualified specifier wins),
+ * files by target (first wins), and cssVars/css deep-merge first-wins per
+ * key. Conflicts produce warnings instead of failures.
+ */
+export declare const mergeItems: (items: ReadonlyArray<Item>) => ResolvedTree;
+//# sourceMappingURL=resolveTree.d.ts.map

package/dist/resolveTree/resolveTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveTree.d.ts","sourceRoot":"","sources":["../../src/resolveTree/resolveTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvC,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE/D;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAA;IACnC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC5C,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC/C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACzC;AAID;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAC1B,WAAW,aAAa,CAAC,MAAM,CAAC,EAChC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,KAC9F,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,EAAE,CAAC,CAqC/B,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,aAAa,CAAC,IAAI,CAAC,KAAG,YAyCvD,CAAA"}

package/dist/resolveTree/resolveTree.js

@@ -0,0 +1,151 @@
+import { Effect, Option } from 'effect';
+const fetchConcurrency = 8;
+/**
+ * Resolves the `registryDependencies` closure of the given specifiers via
+ * breadth-first traversal. `getItem` performs the actual fetch and returns a
+ * canonical key per item; cycles and diamonds are deduplicated on that key.
+ * `maybeOrigin` carries the key of the item that requested the dependency so
+ * bare names can resolve against their origin registry.
+ */
+export const resolve = (rootSpecs, getItem) => Effect.gen(function* () {
+    const seenKeys = new Set();
+    const seenRequests = new Set();
+    const ordered = [];
+    let frontier = rootSpecs.map((spec) => [spec, Option.none()]);
+    while (frontier.length > 0) {
+        const requests = frontier.filter(([spec, maybeOrigin]) => {
+            const requestKey = `${Option.getOrElse(maybeOrigin, () => '')}::${spec}`;
+            if (seenRequests.has(requestKey)) {
+                return false;
+            }
+            seenRequests.add(requestKey);
+            return true;
+        });
+        const fetched = yield* Effect.forEach(requests, ([spec, maybeOrigin]) => getItem(spec, maybeOrigin), {
+            concurrency: fetchConcurrency,
+        });
+        const next = [];
+        for (const { key, item } of fetched) {
+            if (seenKeys.has(key)) {
+                continue;
+            }
+            seenKeys.add(key);
+            ordered.push(item);
+            for (const dependency of item.registryDependencies ?? []) {
+                next.push([dependency, Option.some(key)]);
+            }
+        }
+        frontier = next;
+    }
+    return mergeItems(ordered);
+});
+/**
+ * Merges an ordered list of items into a single plan. Npm dependencies are
+ * deduplicated by package name (first version-qualified specifier wins),
+ * files by target (first wins), and cssVars/css deep-merge first-wins per
+ * key. Conflicts produce warnings instead of failures.
+ */
+export const mergeItems = (items) => {
+    const warnings = [];
+    const dependencies = mergeDependencyLists(items.map((item) => item.dependencies ?? []), warnings);
+    const devDependencies = mergeDependencyLists(items.map((item) => item.devDependencies ?? []), warnings);
+    const files = [];
+    const seenFiles = new Map();
+    for (const item of items) {
+        for (const file of item.files ?? []) {
+            const fileKey = file.target ?? file.path;
+            const existing = seenFiles.get(fileKey);
+            if (existing === undefined) {
+                seenFiles.set(fileKey, file);
+                files.push(file);
+                continue;
+            }
+            if (existing.content !== file.content) {
+                warnings.push(`Skipped duplicate file "${fileKey}" from item "${item.name}" with divergent content`);
+            }
+        }
+    }
+    let cssVars = {};
+    let css = {};
+    for (const item of items) {
+        if (item.cssVars !== undefined) {
+            cssVars = mergeCssVars(cssVars, item.cssVars, item.name, warnings);
+        }
+        if (item.css !== undefined) {
+            css = mergeCss(css, item.css, item.name, warnings);
+        }
+    }
+    return { items, dependencies, devDependencies, files, cssVars, css, warnings };
+};
+const packageName = (spec) => {
+    const versionSeparator = spec.lastIndexOf('@');
+    if (versionSeparator > 0) {
+        return spec.slice(0, versionSeparator);
+    }
+    return spec;
+};
+const mergeDependencyLists = (lists, warnings) => {
+    const byName = new Map();
+    for (const list of lists) {
+        for (const spec of list) {
+            const name = packageName(spec);
+            const existing = byName.get(name);
+            if (existing === undefined) {
+                byName.set(name, spec);
+                continue;
+            }
+            if (existing !== spec) {
+                warnings.push(`Kept dependency "${existing}" over conflicting "${spec}"`);
+            }
+        }
+    }
+    return Array.from(byName.values());
+};
+const mergeVarRecord = (existing, incoming, scope, itemName, warnings) => {
+    if (incoming === undefined) {
+        return existing;
+    }
+    if (existing === undefined) {
+        return incoming;
+    }
+    const merged = { ...existing };
+    for (const [key, value] of Object.entries(incoming)) {
+        const current = merged[key];
+        if (current === undefined) {
+            merged[key] = value;
+            continue;
+        }
+        if (current !== value) {
+            warnings.push(`Kept ${scope} variable "${key}: ${current}" over "${value}" from item "${itemName}"`);
+        }
+    }
+    return merged;
+};
+const mergeCssVars = (existing, incoming, itemName, warnings) => {
+    const theme = mergeVarRecord(existing.theme, incoming.theme, 'theme', itemName, warnings);
+    const light = mergeVarRecord(existing.light, incoming.light, 'light', itemName, warnings);
+    const dark = mergeVarRecord(existing.dark, incoming.dark, 'dark', itemName, warnings);
+    return {
+        ...(theme === undefined ? {} : { theme }),
+        ...(light === undefined ? {} : { light }),
+        ...(dark === undefined ? {} : { dark }),
+    };
+};
+const mergeCss = (existing, incoming, itemName, warnings) => {
+    const merged = { ...existing };
+    for (const [selector, value] of Object.entries(incoming)) {
+        const current = merged[selector];
+        if (current === undefined) {
+            merged[selector] = value;
+            continue;
+        }
+        if (typeof current === 'object' && typeof value === 'object') {
+            merged[selector] = mergeCss(current, value, itemName, warnings);
+            continue;
+        }
+        if (current !== value) {
+            warnings.push(`Kept css "${selector}" over conflicting definition from item "${itemName}"`);
+        }
+    }
+    return merged;
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@foldcn/registry",
+  "version": "0.0.1",
+  "description": "Registry schemas and pure logic for foldcn",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "effect": "4.0.0-beta.88",
+    "postcss": "8.5.16"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-beta.88",
+    "typescript": "6.0.3",
+    "vitest": "4.1.9"
+  }
+}