@pure-ds/core 0.3.0

package/dist/types/src/js/pds-core/pds-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-generator.d.ts","sourceRoot":"","sources":["../../../../../src/js/pds-core/pds-generator.js"],"names":[],"mappings":"AAslKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4CAjBW,UAAU,qBACV,aAAa,EAAE,GACb,OAAO,CAAC,IAAI,CAAC,CAqCzB;AAED;;;;;;;;GAQG;AACH,wCALW,UAAU,WACV,MAAM,EAAE,qBACR,aAAa,EAAE,GACb,OAAO,CAAC,IAAI,CAAC,CAiCzB;AAED;;;;;;GAMG;AACH,sCAHW,MAAM,GACJ,aAAa,CAMzB;AAED;;;;;GAKG;AACH,8BAFa,OAAO,CAInB;AAlsKD;;;GAGG;AACH;IAo/JE;;;;OAIG;IACH,8BAFW,SAAS,QAgCnB;IAED;;;;OAIG;IACH,gDA6CC;IArkKD,0BAyCC;IAxCC;;MAIC;IASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAmC;IA6BrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBC;IAycD;;;;OAIG;IACH,kDAyBC;IA0ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6DC;IAw4GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEC;IAGD,oBAEC;IAkrBD,qBAEC;IACD,yBAEC;IACD,yBAEC;IACD,wBAEC;IACD,yBAMC;IAED;;;;;;OAMG;IACH,oBA6JC;IAGD,4BAEC;IACD,gCAEC;IACD,gCAEC;IACD,+BAEC;IAmBD;;;OAGG;IACH;;;;;;MAoBC;;CA2GF"}

package/dist/types/src/js/pds-core/pds-ontology.d.ts

@@ -0,0 +1,48 @@
+export function findComponentForElement(startEl: any, { maxDepth }?: {
+    maxDepth?: number;
+}): {
+    element: any;
+    componentType: string;
+    displayName: any;
+};
+export function getAllSelectors(): any[];
+export namespace ontology {
+    namespace meta {
+        let name: string;
+        let version: string;
+    }
+    namespace tokens {
+        let colors: string[];
+        let spacing: string[];
+        let typography: string[];
+        let themes: string[];
+    }
+    let primitives: {
+        id: string;
+        name: string;
+        selectors: string[];
+    }[];
+    let components: {
+        id: string;
+        name: string;
+        selectors: string[];
+    }[];
+    let layoutPatterns: {
+        id: string;
+        name: string;
+        selectors: string[];
+        description: string;
+    }[];
+    let utilities: string[];
+    namespace styles {
+        let typography_1: string[];
+        export { typography_1 as typography };
+        export namespace icons {
+            let source: string;
+            let sets: string[];
+        }
+        export let interactive: string[];
+    }
+}
+export default ontology;
+//# sourceMappingURL=pds-ontology.d.ts.map

package/dist/types/src/js/pds-core/pds-ontology.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-ontology.d.ts","sourceRoot":"","sources":["../../../../../src/js/pds-core/pds-ontology.js"],"names":[],"mappings":"AA8FA;;;;;;EAwJC;AAED,yCAKC"}

package/dist/types/src/js/pds-core/pds-paths.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Resolve the public asset root URL for PDS static assets based on the consumer config.
+ * Falls back to "/assets/pds/" when no root is provided. Automatically appends the
+ * "pds" segment when the provided root omits it.
+ *
+ * @param {object} config - Unified PDS configuration.
+ * @param {{ defaultRoot?: string, segment?: string }} [options]
+ * @returns {string} Normalized URL (always ends with a trailing slash).
+ */
+export function resolvePublicAssetURL(config: object, options?: {
+    defaultRoot?: string;
+    segment?: string;
+}): string;
+/**
+ * Extract the raw public root candidate from config for reuse in Node-side helpers.
+ * @param {object} config
+ * @returns {string|null}
+ */
+export function getPublicRootCandidate(config: object): string | null;
+export namespace __internal {
+    export { ensureTrailingSlash };
+    export { appendSegmentIfMissing };
+    export { stripLeadingDotSlash };
+    export { stripDriveLetter };
+    export { stripPublicPrefix };
+    export { URL_PATTERN };
+    export { DEFAULT_SEGMENT };
+}
+declare function ensureTrailingSlash(value?: string): string;
+declare function appendSegmentIfMissing(input?: string, segment?: string): string;
+declare function stripLeadingDotSlash(value: any): any;
+declare function stripDriveLetter(value: any): any;
+declare function stripPublicPrefix(value: any): any;
+declare const URL_PATTERN: RegExp;
+declare const DEFAULT_SEGMENT: "pds";
+export {};
+//# sourceMappingURL=pds-paths.d.ts.map

package/dist/types/src/js/pds-core/pds-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-paths.d.ts","sourceRoot":"","sources":["../../../../../src/js/pds-core/pds-paths.js"],"names":[],"mappings":"AAmCA;;;;;;;;GAQG;AACH,8CAJW,MAAM,YACN;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,MAAM,CA6ClB;AAED;;;;GAIG;AACH,+CAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAMvB;;;;;;;;;;AA9FD,6DAEC;AAED,kFAOC;AAED,uDAEC;AAED,mDAKC;AAED,oDAKC;AAhCD,kCAAmD;AADnD,+BAAwB,KAAK,CAAC"}

package/dist/types/src/js/pds-core/pds-query.d.ts

@@ -0,0 +1,102 @@
+/**
+ * PDSQuery - Smart query engine for the Pure Design System
+ *
+ * Interprets natural language questions and maps them to PDS runtime data
+ * structures (tokens, components, utilities, patterns) using keyword matching,
+ * intent detection, and semantic scoring.
+ *
+ * @example
+ * const query = new PDSQuery(PDS);
+ * const results = await query.search("what is the focus border color on inputs?");
+ * // Returns array of scored results with text, value, icon, category
+ */
+export class PDSQuery {
+    constructor(pds: any);
+    pds: any;
+    intents: {
+        color: string[];
+        spacing: string[];
+        typography: string[];
+        border: string[];
+        radius: string[];
+        shadow: string[];
+        component: string[];
+        utility: string[];
+        layout: string[];
+        pattern: string[];
+        interaction: string[];
+    };
+    entities: {
+        button: string[];
+        input: string[];
+        card: string[];
+        badge: string[];
+        surface: string[];
+        icon: string[];
+        link: string[];
+        nav: string[];
+        modal: string[];
+        drawer: string[];
+        tab: string[];
+        toast: string[];
+    };
+    questionWords: string[];
+    /**
+     * Main search entry point
+     * @param {string} query - Natural language question
+     * @returns {Promise<Array>} Array of results with text, value, icon, category, score
+     */
+    search(query: string): Promise<any[]>;
+    /**
+     * Tokenize and normalize query string
+     */
+    tokenize(text: any): any;
+    /**
+     * Analyze query to extract intents and entities
+     */
+    analyzeQuery(tokens: any, fullText: any): {
+        intents: Set<any>;
+        entities: Set<any>;
+        modifiers: Set<any>;
+        isQuestion: boolean;
+        tokens: any;
+        fullText: any;
+    };
+    /**
+     * Query color tokens and surfaces
+     */
+    queryColors(context: any, query: any): any[];
+    /**
+     * Query utility classes
+     */
+    queryUtilities(context: any, query: any): any[];
+    /**
+     * Query components
+     */
+    queryComponents(context: any, query: any): any[];
+    /**
+     * Query layout patterns
+     */
+    queryPatterns(context: any, query: any): any[];
+    /**
+     * Query typography tokens
+     */
+    queryTypography(context: any, query: any): any[];
+    /**
+     * Query spacing tokens
+     */
+    querySpacing(context: any, query: any): any[];
+    /**
+     * Calculate match score between query and target text
+     */
+    scoreMatch(query: any, target: any): number;
+    /**
+     * Generate example code for a primitive
+     */
+    generatePrimitiveExample(primitive: any): string;
+    /**
+     * Describe utility class purpose
+     */
+    describeUtility(utilClass: any): "Apply animated gradient border effect" | "Apply glowing border effect" | "Flexbox container utility" | "Grid container utility" | "Set gap between flex/grid children" | "Align items in flex container" | "Justify content in flex container" | "Group buttons with connected styling" | "Utility class for styling";
+}
+//# sourceMappingURL=pds-query.d.ts.map

package/dist/types/src/js/pds-core/pds-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-query.d.ts","sourceRoot":"","sources":["../../../../../src/js/pds-core/pds-query.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;IACE,sBAoCC;IAnCC,SAAc;IAGd;;;;;;;;;;;;MAYC;IAGD;;;;;;;;;;;;;MAaC;IAGD,wBAAqG;IAGvG;;;;OAIG;IACH,cAHW,MAAM,GACJ,OAAO,OAAO,CA0D1B;IAED;;OAEG;IACH,yBAKC;IAED;;OAEG;IACH;;;;;;;MAkCC;IAED;;OAEG;IACH,6CA0FC;IAED;;OAEG;IACH,gDAiEC;IAED;;OAEG;IACH,iDAyDC;IAED;;OAEG;IACH,+CA8CC;IAED;;OAEG;IACH,iDAiCC;IAED;;OAEG;IACH,8CAwBC;IAED;;OAEG;IACH,4CAsBC;IAED;;OAEG;IACH,iDAcC;IAED;;OAEG;IACH,wVAWC;CACF"}

package/dist/types/src/js/pds-core/pds-registry.d.ts

@@ -0,0 +1,40 @@
+export const registry: PDSRegistry;
+declare class PDSRegistry {
+    _mode: string;
+    _designer: any;
+    _staticPaths: {
+        tokens: string;
+        primitives: string;
+        components: string;
+        utilities: string;
+        styles: string;
+    };
+    /**
+     * Set the designer instance and switch to live mode
+     */
+    setDesigner(designer: any, meta?: {}): void;
+    /**
+     * Switch to static mode with custom paths
+     * Called by consumers who want to use static CSS files
+     */
+    setStaticMode(paths?: {}): void;
+    /**
+     * Get stylesheet for adoption in shadow DOM
+     * Returns CSSStyleSheet object (constructable stylesheet)
+     */
+    getStylesheet(layer: any): Promise<any>;
+    /**
+     * Get current mode
+     */
+    get mode(): string;
+    /**
+     * Check if in live mode
+     */
+    get isLive(): boolean;
+    /**
+     * Check if designer is available
+     */
+    get hasDesigner(): boolean;
+}
+export {};
+//# sourceMappingURL=pds-registry.d.ts.map

package/dist/types/src/js/pds-core/pds-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-registry.d.ts","sourceRoot":"","sources":["../../../../../src/js/pds-core/pds-registry.js"],"names":[],"mappings":"AAgIA,mCAA0C;AA3H1C;IAEI,cAAqB;IACrB,eAAqB;IACrB;;;;;;MAMC;IAGH;;OAEG;IACH,4CASC;IAED;;;OAGG;IACH,gCAKC;IAED;;;OAGG;IACH,wCAgCC;IA0BD;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,2BAEC;CACF"}

package/dist/types/src/js/pds.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Public PDS runtime object exported to consumers.
+ *
+ * This object exposes the core runtime building blocks for the Pure Design System.
+ * It intentionally provides a small, stable surface area so consuming apps can:
+ * - programmatically generate design system artifacts (via `Generator`),
+ * - adopt styles into Shadow DOM (via `adoptLayers` / `adoptPrimitives`),
+ * - query runtime mode and obtain constructable stylesheets (via `registry`).
+ *
+ * Common events in the PDS ecosystem (emitted by other packages/components):
+ * - `design-updated` — emitted by the designer component when the in-memory design changes (detail: { config }).
+ * - `pds-generated` — emitted by the PDS configurator when generation completes (detail: { modules, meta }).
+ * - `pds-error` — emitted by the PDS configurator when generation fails (detail: Error).
+ *
+ * Error handling notes:
+ * - Methods that perform dynamic imports (e.g. `adoptLayers` via the registry) may log and return fallbacks
+ *   rather than throwing; consumers should check return values (e.g. null) and listen for `pds-error` in UI flows.
+ * - `createStylesheet(css)` will throw synchronously if the provided CSS cannot be parsed by the browser's
+ *   `CSSStyleSheet.replaceSync()` — callers should guard invalid input or wrap calls in try/catch.
+ */
+export type PDSAPI = {
+    /**
+     * - Generator class to produce design system assets
+     */
+    Generator: typeof import("./pds-core/pds-generator.js").Generator;
+    /**
+     * - Singleton runtime registry for live/static mode
+     */
+    registry: import("./pds-core/pds-registry.js").PDSRegistry;
+    /**
+     * - Ontology helpers and metadata for components
+     */
+    ontology: any;
+    /**
+     * - Adopt multiple layers into a ShadowRoot. May log errors and fallback to additionalSheets when static imports fail.
+     */
+    adoptLayers: (shadowRoot: ShadowRoot, layers?: string[], additionalSheets?: CSSStyleSheet[]) => Promise<void>;
+    /**
+     * - Adopt primitives layer into a ShadowRoot. Designed as a convenience for components.
+     */
+    adoptPrimitives: (shadowRoot: ShadowRoot, additionalSheets?: CSSStyleSheet[]) => Promise<void>;
+    /**
+     * - Create a constructable stylesheet from CSS text.
+     */
+    createStylesheet: (css: string) => CSSStyleSheet;
+};
+/** @type {PDSAPI & PDSBase} */
+export const PDS: PDSAPI & PDSBase;
+/**
+ * Validate a design configuration for accessibility sanity checks.
+ * Currently validates color contrast for primary buttons and base surface text
+ * in both light and dark themes.
+ *
+ * @param {object} designConfig - A full or partial PDS config object
+ * @param {object} [options]
+ * @param {number} [options.minContrast=4.5] - Minimum contrast ratio for normal text
+ * @returns {{ ok: boolean, issues: Array<{path:string, message:string, ratio:number, min:number, context?:string}> }}
+ */
+export function validateDesign(designConfig?: object, options?: {
+    minContrast?: number;
+}): {
+    ok: boolean;
+    issues: Array<{
+        path: string;
+        message: string;
+        ratio: number;
+        min: number;
+        context?: string;
+    }>;
+};
+/**
+ * Public PDS runtime object exported to consumers.
+ *
+ * This object exposes the core runtime building blocks for the Pure Design System.
+ * It intentionally provides a small, stable surface area so consuming apps can:
+ * - programmatically generate design system artifacts (via `Generator`),
+ * - adopt styles into Shadow DOM (via `adoptLayers` / `adoptPrimitives`),
+ * - query runtime mode and obtain constructable stylesheets (via `registry`).
+ *
+ * Common events in the PDS ecosystem (emitted by other packages/components):
+ * - `design-updated` — emitted by the designer component when the in-memory design changes (detail: { config }).
+ * - `pds-generated` — emitted by the PDS configurator when generation completes (detail: { modules, meta }).
+ * - `pds-error` — emitted by the PDS configurator when generation fails (detail: Error).
+ *
+ * Error handling notes:
+ * - Methods that perform dynamic imports (e.g. `adoptLayers` via the registry) may log and return fallbacks
+ *   rather than throwing; consumers should check return values (e.g. null) and listen for `pds-error` in UI flows.
+ * - `createStylesheet(css)` will throw synchronously if the provided CSS cannot be parsed by the browser's
+ *   `CSSStyleSheet.replaceSync()` — callers should guard invalid input or wrap calls in try/catch.
+ *
+ * @typedef {Object} PDSAPI
+ * @property {typeof import("./pds-core/pds-generator.js").Generator} Generator - Generator class to produce design system assets
+ * @property {import("./pds-core/pds-registry.js").PDSRegistry} registry - Singleton runtime registry for live/static mode
+ * @property {any} ontology - Ontology helpers and metadata for components
+ * @property {(shadowRoot: ShadowRoot, layers?: string[], additionalSheets?: CSSStyleSheet[]) => Promise<void>} adoptLayers - Adopt multiple layers into a ShadowRoot. May log errors and fallback to additionalSheets when static imports fail.
+ * @property {(shadowRoot: ShadowRoot, additionalSheets?: CSSStyleSheet[]) => Promise<void>} adoptPrimitives - Adopt primitives layer into a ShadowRoot. Designed as a convenience for components.
+ * @property {(css:string) => CSSStyleSheet} createStylesheet - Create a constructable stylesheet from CSS text. @throws {DOMException} on invalid CSS in some browsers.
+ * @property {() => boolean} isLiveMode - Returns true when running in live/designer-backed mode
+ * @property {(el: Element) => import("./pds-core/pds-ontology.js").ComponentDef | null} findComponentForElement - Helper to find a component definition for a DOM element
+ */
+/**
+ * Workspace for the Pure Design System runtime API
+ * PDS is now an EventTarget so consumers can subscribe to a single, consistent
+ * event bus instead of listening on window/document or individual elements.
+ */
+declare class PDSBase extends EventTarget {
+}
+export {};
+//# sourceMappingURL=pds.d.ts.map

package/dist/types/src/js/pds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds.d.ts","sourceRoot":"","sources":["../../../../src/js/pds.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;eAuBc,cAAc,6BAA6B,EAAE,SAAS;;;;cACtD,OAAO,4BAA4B,EAAE,WAAW;;;;cAChD,GAAG;;;;iBACH,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,gBAAgB,CAAC,EAAE,aAAa,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC;;;;qBAChG,CAAC,UAAU,EAAE,UAAU,EAAE,gBAAgB,CAAC,EAAE,aAAa,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC;;;;sBAC7E,CAAC,GAAG,EAAC,MAAM,KAAK,aAAa;;AAW3C,+BAA+B;AAC/B,kBADW,MAAM,GAAG,OAAO,CACD;AAyR1B;;;;;;;;;GASG;AACH,8CALW,MAAM,YAEd;IAAyB,WAAW,GAA5B,MAAM;CACd,GAAU;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAC,OAAO,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,GAAG,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,MAAM,CAAA;KAAC,CAAC,CAAA;CAAE,CAyIpH;AAhdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;GAIG;AACH;CAAoC"}

package/dist/types/src/pds-core/pds-api.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Generate modules map and metadata from a config object.
+ * @param {object} config
+ * @param {object} [opts]
+ * @returns {Promise<{modules: Record<string,string>, meta: object}>}
+ */
+export function generate(config: object, opts?: object): Promise<{
+    modules: Record<string, string>;
+    meta: object;
+}>;
+/**
+ * Read config from file and generate modules.
+ * @param {string} configPath
+ * @param {object} [opts]
+ */
+export function generateFromFile(configPath: string, opts?: object): Promise<{
+    modules: Record<string, string>;
+    meta: object;
+}>;
+/**
+ * Watch a config file and call the writer on changes.
+ * @param {string} configPath
+ * @param {string} outDir
+ * @param {{onWrite?:Function}} opts
+ */
+export function watch(configPath: string, outDir: string, opts?: {
+    onWrite?: Function;
+}): {
+    close(): void;
+};
+//# sourceMappingURL=pds-api.d.ts.map

package/dist/types/src/pds-core/pds-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-api.d.ts","sourceRoot":"","sources":["../../../../src/pds-core/pds-api.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,iCAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,CAgCnE;AAiBD;;;;GAIG;AACH,6CAHW,MAAM,SACN,MAAM;aApDc,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC;UAAQ,MAAM;GA+DjE;AAED;;;;;GAKG;AACH,kCAJW,MAAM,UACN,MAAM,SACN;IAAC,OAAO,CAAC,WAAS;CAAC;;EA0B7B"}

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@pure-ds/core",
+  "shortname": "pds",
+  "version": "0.3.0",
+  "description": "Pure Design System - Why develop a Design System when you can generate one?",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pure-Web-Foundation/pure-ds.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Pure-Web-Foundation/pure-ds/issues"
+  },
+  "homepage": "https://puredesignsystem.z6.web.core.windows.net/",
+  "keywords": [
+    "design-system",
+    "css",
+    "web-components",
+    "lit",
+    "constructable-stylesheets",
+    "tokens",
+    "utilities",
+    "a11y"
+  ],
+  "type": "module",
+  "main": "./public/assets/js/pds.js",
+  "module": "./public/assets/js/pds.js",
+  "types": "./dist/types/pds.d.ts",
+  "bin": {
+    "pds-export": "packages/pds-cli/bin/pds-static.js",
+    "pds-sync-assets": "packages/pds-cli/bin/sync-assets.js",
+    "pds-build-icons": "packages/pds-cli/bin/pds-build-icons.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/js/pds.d.ts",
+      "import": "./public/assets/js/pds.js"
+    },
+    "./pds-core": "./src/js/pds.js",
+    "./pds-configurator": "./src/js/pds-configurator/pds-configurator.js",
+    "./auto-define/*": "./public/auto-define/*"
+  },
+  "files": [
+    "dist/types/",
+    "public/assets/js/",
+    "public/assets/pds/components/",
+    "public/assets/pds/vscode-custom-data.json",
+    "public/assets/pds/pds.css-data.json",
+    "public/assets/pds/pds-css-complete.json",
+    "public/auto-define/",
+    "public/pds/components/",
+    "public/assets/pds/icons/pds-icons.svg",
+    "packages/pds-cli/bin/",
+    "packages/pds-cli/lib/",
+    "src/js/pds.d.ts",
+    "src/js/pds.js",
+    "src/js/pds-core/",
+    "src/js/pds-configurator/",
+    "custom-elements.json",
+    "custom-elements-manifest.config.js",
+    "pds.html-data.json",
+    "pds.css-data.json",
+    "readme.md",
+    "INTELLISENSE.md",
+    "CSS-INTELLISENSE-LIMITATION.md",
+    "CSS-INTELLISENSE-QUICK-REF.md"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "node esbuild-dev.js",
+    "prebuild": "npm run types",
+    "build": "node esbuild-build.js",
+    "types": "tsc -p tsconfig.json && node scripts/sync-types.mjs",
+    "postinstall": "node packages/pds-cli/bin/postinstall.js",
+    "prepds:export": "npm run types",
+    "pds:export": "node packages/pds-cli/bin/pds-static.js",
+    "pds:build-icons": "node packages/pds-cli/bin/pds-build-icons.js",
+    "pds:manifest": "node packages/pds-cli/bin/generate-manifest.js",
+    "pds:css-data": "node packages/pds-cli/bin/generate-css-data.js",
+    "pds:dx": "node packages/pds-cli/bin/pds-dx.js",
+    "storybook:generate": "cd packages/pds-storybook && npm run generate-stories",
+    "storybook:dev": "cd packages/pds-storybook && npm run storybook:dev",
+    "storybook:build": "cd packages/pds-storybook && npm run storybook:build"
+  },
+  "author": "Marc van Neerven",
+  "license": "ISC",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@custom-elements-manifest/analyzer": "^0.9.9",
+    "esbuild": "^0.19.0",
+    "fs-extra": "^11.1.1",
+    "typescript": "^5.6.3",
+    "@types/node": "^22.10.2"
+  },
+  "dependencies": {
+    "lit": "^3.3.1",
+    "pure-web": "1.1.30"
+  },
+  "customElements": "custom-elements.json"
+}

package/packages/pds-cli/README.md

@@ -0,0 +1,15 @@
+# PDS CLI
+
+Minimal CLI to generate PDS artifacts and optionally watch a config file.
+
+Commands:
+
+- `pds-cli generate --config ./pds.config.js --out ./public/pds`
+- `pds-cli watch --config ./pds.config.js --out ./public/pds`
+
+Notes:
+
+- The `--config` can be a JS/JSON file resolving to your PDS configuration.
+- Output includes constructable stylesheet modules (pds-*.css.js) and plain CSS files.
+
+This CLI is intentionally tiny and uses the repository's `pds-api` and `fs-writer` utilities.