@ptkl/toolkit 0.8.0 → 0.8.12

package/dist/bin/toolkit.js

@@ -14,12 +14,13 @@ program.hook('preAction', (thisCommand, actionCommand) => {
 });
 commands.forEach(c => program.addCommand(c));
 program.parseAsync(process.argv).catch((err) => {
+    console.log("An error occurred while executing the command.", err);
     const { response } = err;
     if (response && response.data) {
-        console.error(response.data.message);
+        console.error(response.data.message || "An error occurred with the API request.");
     }
     else {
-        console.error(err.message || err);
+        console.error(err.message || err || "An unknown error occurred.");
     }
     process.exit(1);
 });

package/dist/commands/apiUsers.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "@ptkl/sdk";
+import { Platform as Api } from "@ptkl/sdk";
 import OutputFormatCommand from "./outputCommand.js";
 class ApiUsersCommand {
     register() {

package/dist/commands/apps.js

@@ -1,6 +1,6 @@
 import { Command, Option } from "commander";
 import util from "../lib/util.js";
-import Api from "@ptkl/sdk";
+import { Platform as Api } from "@ptkl/sdk";
 import { build, createServer } from 'vite';
 import { c } from 'tar';
 import { Writable } from "stream";
@@ -129,7 +129,7 @@ class AppsCommand {
     async bundle(options) {
         const { path, upload } = options;
         const module = await import(`${path}/ptkl.config.js`);
-        const { views, name, version, distPath, icon, label, permissions, scripts, } = module.default ?? {};
+        const { views, name, version, distPath, icon, label, permissions, install_permissions, runtime_permissions, requires, scripts, } = module.default ?? {};
         // build manifest file
         const manifest = {
             name,
@@ -138,6 +138,9 @@ class AppsCommand {
             label,
             icon,
             permissions,
+            install_permissions: install_permissions ?? [],
+            runtime_permissions: runtime_permissions ?? [],
+            requires: requires ?? null,
             scripts,
         };
         const profile = Util.getCurrentProfile();

package/dist/commands/component.js

@@ -4,7 +4,7 @@ import { WebSocketServer } from "ws";
 import { resolve, join, dirname } from "path";
 import { rollup } from "rollup";
 import util from "../lib/util.js";
-import Api from "@ptkl/sdk";
+import { Platform as Api } from "@ptkl/sdk";
 import { mkdirSync, writeFileSync, rmSync, readdirSync, existsSync, readFileSync } from "fs";
 import { nodeResolve } from '@rollup/plugin-node-resolve';
 // @ts-ignore
@@ -114,7 +114,7 @@ class ComponentCommand {
             // Merge user packages with internal dependencies
             const userPackages = componentConfig.packages || {};
             const dependencies = {
-                '@ptkl/sdk': '^0.9.12',
+                '@ptkl/sdk': '^1.0.0',
                 // Lit is bundled into the component, not provided by platform
                 ...(framework === 'lit' ? {
                     'lit': frameworkVersion ? `^${frameworkVersion}` : '^3.0.0'
@@ -301,16 +301,15 @@ class ComponentCommand {
             console.error(`❌ Build failed: ${error.message}`);
             socket.send(JSON.stringify({ error: error.message }));
         }
-        // Temporary: Keep files for inspection
-        // TODO: Uncomment cleanup when ready
-        // finally {
-        //   try {
-        //     rmSync(tempDir, { recursive: true, force: true });
-        //     console.log(`Cleaned up temporary directory: ${tempDir}`);
-        //   } catch (cleanupError) {
-        //     console.error(`Failed to clean up temporary directory: ${cleanupError}`);
-        //   }
-        // }
+        finally {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+                console.log(`Cleaned up temporary directory: ${tempDir}`);
+            }
+            catch (cleanupError) {
+                console.error(`Failed to clean up temporary directory: ${cleanupError}`);
+            }
+        }
     }
     async buildLegacy(nodes, version, engine, socket) {
         try {

package/dist/commands/forge.js

@@ -2,7 +2,8 @@ import { Command } from "commander";
 import { build, createServer } from 'vite';
 import { c } from 'tar';
 import { Writable } from "stream";
-import { writeFileSync } from "fs";
+import { writeFileSync, readFileSync } from "fs";
+import axios from 'axios';
 import Util from "../lib/util.js";
 import { join } from 'path';
 class ForgeCommand {
@@ -26,7 +27,19 @@ class ForgeCommand {
             .action(this.runDev))
             .addCommand(new Command("list")
             .description("List all available apps")
-            .action(this.listApps));
+            .action(this.listApps))
+            .addCommand(new Command("install")
+            .description("Dry-run the app install script locally against the active profile (no actual installation). Runs for both dev and live by default.")
+            .requiredOption("-p, --path <path>", "Path to the app directory (where ptkl.config.js is located)")
+            .option("--env <env>", "Run for a specific env only (dev or live). Omit to run for both.")
+            .option("-b, --bundle", "Build the bundle before running the install script")
+            .action((options) => this.install(options)))
+            .addCommand(new Command("uninstall")
+            .description("Dry-run the app uninstall script locally against the active profile (no actual uninstallation). Runs for both dev and live by default.")
+            .requiredOption("-p, --path <path>", "Path to the app directory (where ptkl.config.js is located)")
+            .option("--env <env>", "Run for a specific env only (dev or live). Omit to run for both.")
+            .option("-b, --bundle", "Build the bundle before running the uninstall script")
+            .action((options) => this.uninstall(options)));
     }
     async bundle(options) {
         const { path, upload } = options;
@@ -36,7 +49,13 @@ class ForgeCommand {
             // Change to the app directory
             process.chdir(path);
             const module = await import(`${path}/ptkl.config.js`);
-            const { views, name, version, distPath, icon, type, label, permissions, scripts, ssrRenderer, } = module.default ?? {};
+            const { views, name, version, distPath, icon, type, label, permissions, install_permissions, runtime_permissions, entitlements, requires, scripts, ssrRenderer, } = module.default ?? {};
+            // Validate combined permissions limit
+            const rtPerms = runtime_permissions ?? [];
+            const ents = entitlements ?? [];
+            if (rtPerms.length + ents.length > 100) {
+                throw new Error(`Combined runtime_permissions (${rtPerms.length}) and entitlements (${ents.length}) must not exceed 100 entries`);
+            }
             // build manifest file
             const manifest = {
                 name,
@@ -45,6 +64,10 @@ class ForgeCommand {
                 label,
                 icon,
                 permissions,
+                install_permissions: install_permissions ?? [],
+                runtime_permissions: runtime_permissions ?? [],
+                entitlements: entitlements ?? [],
+                requires: requires ?? null,
                 scripts: {},
                 type: type || 'platform', // default to 'platform' if not specified
                 ssrRenderer,
@@ -169,10 +192,7 @@ class ForgeCommand {
                                         format: 'esm',
                                         entryFileNames: `[name].script.js`,
                                         assetFileNames: (assetInfo) => {
-                                            return '[name].[ext]'; // Example: Customize the output file name format
-                                        },
-                                        globals: {
-                                            axios: 'axiosAdapter'
+                                            return '[name].[ext]';
                                         },
                                         manualChunks: undefined,
                                         inlineDynamicImports: true,
@@ -186,24 +206,17 @@ class ForgeCommand {
                                         for (const fileName in bundle) {
                                             const chunk = bundle[fileName];
                                             if (chunk.type === 'chunk' && chunk.code) {
-                                                // Replace import statements with direct variable assignment from globals
-                                                // Handle both regular and minified versions
-                                                let code = chunk.code.replace(/import\s*(\w+)\s*from\s*['"]axios['"]\s*;?/g, 'const $1=axiosAdapter;');
-                                                code = code.replace(/import\s*\{([^}]+)\}\s*from\s*['"]axios['"]\s*;?/g, (match, imports) => {
-                                                    // Handle named imports like { default as axios }
-                                                    const parts = imports.split(',').map(i => i.trim());
-                                                    return parts.map(part => {
-                                                        if (part.includes(' as ')) {
-                                                            const [original, alias] = part.split(' as ').map(s => s.trim());
-                                                            if (original === 'default') {
-                                                                return `const ${alias}=axiosAdapter;`;
-                                                            }
-                                                            return `const ${alias}=axiosAdapter.${original};`;
-                                                        }
-                                                        return `const ${part}=axiosAdapter.${part};`;
-                                                    }).join('');
-                                                });
-                                                // Wrap in async function (minified)
+                                                let code = chunk.code;
+                                                // Replace `import X from 'axios'` → `const X = axiosAdapter`
+                                                // ([\w$]+ handles both regular names and $ from minification)
+                                                // \s* instead of \s+ because minifier removes space before the quote
+                                                code = code.replace(/import\s+([\w$]+)\s+from\s*['"]axios['"]\s*;?\n?/g, 'const $1=axiosAdapter;\n');
+                                                // Replace `import { foo, bar as baz } from 'axios'`
+                                                code = code.replace(/import\s*\{([^}]+)\}\s*from\s*['"]axios['"]\s*;?\n?/g, (_, imports) => imports.split(',').map((part) => {
+                                                    const [orig, alias] = part.trim().split(/\s+as\s+/).map((s) => s.trim());
+                                                    return `const ${alias || orig}=axiosAdapter${orig === 'default' || !alias ? '' : `.${orig}`};\n`;
+                                                }).join(''));
+                                                // Wrap in async function so sandbox (isolate-vm / new Function) gets a callable back
                                                 chunk.code = `return async()=>{try{${code}}catch(err){const errorObj={_error_:true,message:err.message,name:err.name||'Error',stack:err.stack};Object.keys(err).forEach(key=>{errorObj[key]=err[key]});if(err.data)errorObj.data=err.data;if(err.statusCode)errorObj.statusCode=err.statusCode;if(err.response)errorObj.response=err.response;if(err.code)errorObj.code=err.code;return errorObj}}`;
                                             }
                                         }
@@ -322,5 +335,70 @@ class ForgeCommand {
         const { data } = await forge.list();
         console.log(data);
     }
+    async install(options) {
+        const { path, env, bundle } = options;
+        if (bundle)
+            await this.bundle({ path, upload: false });
+        const envs = env ? [env] : ['dev', 'live'];
+        for (const e of envs) {
+            await ForgeCommand._runScript(path, 'install', e);
+        }
+    }
+    async uninstall(options) {
+        const { path, env, bundle } = options;
+        if (bundle)
+            await this.bundle({ path, upload: false });
+        const envs = env ? [env] : ['dev', 'live'];
+        for (const e of envs) {
+            await ForgeCommand._runScript(path, 'uninstall', e);
+        }
+    }
+    static async _runScript(appPath, scriptType, env = 'dev') {
+        const module = await import(`${appPath}/ptkl.config.js`);
+        const { name, distPath, scripts } = module.default ?? {};
+        if (!name)
+            throw new Error(`Could not read app name from ${appPath}/ptkl.config.js`);
+        if (!scripts?.[scriptType]) {
+            console.log(`No '${scriptType}' script defined in ptkl.config.js`);
+            return;
+        }
+        const scriptFile = join(distPath, `${scriptType}.script.js`);
+        let scriptCode;
+        try {
+            scriptCode = readFileSync(scriptFile, 'utf-8');
+        }
+        catch {
+            throw new Error(`Script file not found: ${scriptFile}\nRun 'forge bundle' first.`);
+        }
+        const profile = Util.getCurrentProfile();
+        global.window = {
+            __ENV_VARIABLES__: {
+                API_HOST: profile.host,
+                INTEGRATION_API: `${profile.host}/luma/integrations`,
+                PROJECT_API_TOKEN: profile.token,
+                PROJECT_ENV: env,
+            }
+        };
+        global.axiosAdapter = axios;
+        console.log(`Running ${scriptType} script for '${name}' (profile: ${profile.name}, env: ${env})...\n`);
+        // The bundle is: `return async()=>{try{ ...code... }catch(err){return {_error_:true,...}}}`
+        // new Function(scriptCode) creates a function whose body is that code.
+        // Calling it returns the async function, which we then await.
+        const scriptFn = new Function(scriptCode)();
+        const result = await scriptFn();
+        // Cleanup globals
+        delete global.window;
+        delete global.axiosAdapter;
+        if (result && result._error_) {
+            console.error(`❌ Script error: ${result.message}`);
+            if (result.stack)
+                console.error(result.stack);
+            process.exit(1);
+        }
+        console.log(`✅ ${scriptType} script completed`);
+        if (result !== undefined && result !== null) {
+            console.log('Result:', JSON.stringify(result, null, 2));
+        }
+    }
 }
 export default new ForgeCommand();

package/dist/commands/functions.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "@ptkl/sdk";
+import { Platform as Api } from "@ptkl/sdk";
 import OutputFormatCommand from "./outputCommand.js";
 class FunctionsCommand {
     register() {

package/dist/commands/generate-types.js

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import util from "../lib/util.js";
+import { Platform as Api } from "@ptkl/sdk/beta";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { idlToModuleAugmentation } from "../lib/idlToDts.js";
+class GenerateTypesCommand {
+    register() {
+        return new Command('generate-types')
+            .description('Fetch IDL definitions from the platform and emit a TypeScript ' +
+            'module-augmentation .d.ts file that gives your project typed ' +
+            'component models, component functions, and platform functions.')
+            .option('--output <path>', 'Path where the .d.ts file will be written', './types/ptkl.d.ts')
+            .option('--env <env>', 'Environment to fetch IDL from (uses current profile default when omitted)')
+            .action(this.generate);
+    }
+    async generate(options) {
+        const profile = util.getCurrentProfile();
+        const client = new Api({ token: profile.token, host: profile.host, env: options.env });
+        console.log(`⏳ Fetching IDL…`);
+        const { data } = await client.system().idl();
+        console.log(`✅ IDL fetched: ${Object.keys(data.components ?? {}).length} component(s), ${Object.keys(data.functions ?? {}).length} platform function(s)`);
+        const dts = idlToModuleAugmentation(data);
+        const outputPath = resolve(process.cwd(), options.output);
+        mkdirSync(dirname(outputPath), { recursive: true });
+        writeFileSync(outputPath, dts, 'utf8');
+        const componentCount = Object.keys(data.components ?? {}).length;
+        const functionCount = Object.keys(data.functions ?? {}).length;
+        console.log(`✅ Types generated: ${outputPath}\n` +
+            `   ${componentCount} component(s)  •  ${functionCount} platform function(s)`);
+        console.log('');
+        console.log('Next steps:');
+        console.log('  1. Include the file in your tsconfig.json "include" array, or');
+        console.log(`     add a triple-slash reference: /// <reference path="${options.output}" />`);
+        console.log('  2. Enjoy typed component models and functions!');
+    }
+}
+export default new GenerateTypesCommand();

package/dist/commands/index.js

@@ -8,6 +8,8 @@ import apps from "./apps.js";
 import role from "./role.js";
 import forge from "./forge.js";
 import component from "./component.js";
+import generateTypes from "./generate-types.js";
+import validateIDL from "./validate-idl.js";
 export const commands = [
     profile.register(),
     users.register(),
@@ -16,6 +18,8 @@ export const commands = [
     role.register(),
     forge.register(),
     component.register(),
+    generateTypes.register(),
+    validateIDL.register(),
     new Command('init')
         .description("Init protokol toolkit")
         .action(Util.init)

package/dist/commands/profile.js

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
 import cli from "../lib/cli.js";
-import { APIUser, User } from "@ptkl/sdk";
+import { APIUser, Users as User } from "@ptkl/sdk";
 import password from '@inquirer/password';
 class ProfileCommand {
     register() {

package/dist/commands/role.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "@ptkl/sdk";
+import { Platform as Api } from "@ptkl/sdk";
 import OutputFormatCommand from "./outputCommand.js";
 class RoleCommand {
     register() {

package/dist/commands/users.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "@ptkl/sdk";
+import { Platform as Api } from "@ptkl/sdk";
 class ApiUsersCommand {
     register() {
         return new Command("users")

package/dist/commands/validate-idl.js

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import util from "../lib/util.js";
+import { Platform as Api } from "@ptkl/sdk/beta";
+class ValidateIDLCommand {
+    register() {
+        return new Command('validate-idl')
+            .description('Validate a value against a component, extension, or platform-function IDL. ' +
+            'Pass either --ref to identify the target by ref, or --idl-file to supply an ' +
+            'inline IDL. The value to validate can be given as a JSON string (--value) or ' +
+            'read from a file (--value-file).')
+            .option('--ref <ref>', 'Compound ref identifying the IDL target.\n' +
+            '  component:ns::name          — base component, default schema\n' +
+            '  component:ns::name.schema   — base component, named schema\n' +
+            '  extension:ns::name/extName  — extension IDL on a component\n' +
+            '  pfn:functionName            — platform function input')
+            .option('--idl-file <path>', 'Path to a JSON file containing an inline EntityIDL object. Mutually exclusive with --ref.')
+            .option('--field <field>', 'Field key to validate against (required for component/extension refs; ignored for pfn).')
+            .option('--value <json>', 'JSON-encoded value to validate. Mutually exclusive with --value-file.')
+            .option('--value-file <path>', 'Path to a JSON file whose contents are the value to validate. Mutually exclusive with --value.')
+            .option('--env <env>', 'Environment to run validation in (uses current profile default when omitted).')
+            .action(this.run);
+    }
+    async run(options) {
+        // ── mutual-exclusion guards ────────────────────────────────────────────
+        if (options.ref && options.idlFile) {
+            console.error('❌  Provide either --ref or --idl-file, not both.');
+            process.exit(1);
+        }
+        if (!options.ref && !options.idlFile) {
+            console.error('❌  Provide either --ref or --idl-file.');
+            process.exit(1);
+        }
+        if (options.value !== undefined && options.valueFile) {
+            console.error('❌  Provide either --value or --value-file, not both.');
+            process.exit(1);
+        }
+        if (options.value === undefined && !options.valueFile) {
+            console.error('❌  Provide --value or --value-file.');
+            process.exit(1);
+        }
+        // ── resolve value ──────────────────────────────────────────────────────
+        let rawValue;
+        if (options.valueFile) {
+            const path = resolve(process.cwd(), options.valueFile);
+            if (!existsSync(path)) {
+                console.error(`❌  Value file not found: ${path}`);
+                process.exit(1);
+            }
+            rawValue = readFileSync(path, 'utf8');
+        }
+        else {
+            rawValue = options.value;
+        }
+        let value;
+        try {
+            value = JSON.parse(rawValue);
+        }
+        catch {
+            console.error('❌  Could not parse value as JSON.');
+            process.exit(1);
+        }
+        // ── resolve inline IDL ─────────────────────────────────────────────────
+        let inlineIDL;
+        if (options.idlFile) {
+            const path = resolve(process.cwd(), options.idlFile);
+            if (!existsSync(path)) {
+                console.error(`❌  IDL file not found: ${path}`);
+                process.exit(1);
+            }
+            try {
+                inlineIDL = JSON.parse(readFileSync(path, 'utf8'));
+            }
+            catch {
+                console.error('❌  Could not parse IDL file as JSON.');
+                process.exit(1);
+            }
+        }
+        const profile = util.getCurrentProfile();
+        const client = new Api({ token: profile.token, host: profile.host, env: options.env });
+        const target = options.ref ? `ref: ${options.ref}` : `inline IDL (${options.idlFile})`;
+        console.log(`⏳ Validating value against ${target}…`);
+        let result;
+        try {
+            const req = { value };
+            if (options.ref)
+                req.ref = options.ref;
+            if (inlineIDL)
+                req.idl = inlineIDL;
+            if (options.field)
+                req.field = options.field;
+            const { data } = await client.system().idlValidate(req);
+            result = data;
+        }
+        catch (err) {
+            const msg = err?.response?.data?.message ?? err?.message ?? String(err);
+            console.error(`❌  Request failed: ${msg}`);
+            process.exit(1);
+        }
+        if (result.valid) {
+            console.log('✅  Valid');
+            return;
+        }
+        console.error('✗  Invalid');
+        if (result.errors?.length) {
+            for (const e of result.errors) {
+                const loc = e.field ? ` (${e.field})` : '';
+                console.error(`   •${loc} ${e.message}`);
+            }
+        }
+        process.exit(1);
+    }
+}
+export default new ValidateIDLCommand();

package/dist/lib/idlToDts.js

@@ -0,0 +1,242 @@
+/**
+ * IDL → TypeScript module-augmentation generator.
+ *
+ * Mirror of the runtime idlToDts.js used by the Monaco editor, but output
+ * targets a `declare module "@ptkl/sdk"` block so the generated `.d.ts` file
+ * extends the SDK's open interfaces at build time.
+ */
+// ── Primitive type conversion ─────────────────────────────────────────────────
+function idlTypeNodeToTs(node, indent = 0) {
+    if (!node)
+        return 'any';
+    switch (node.type) {
+        case 'string': return 'string';
+        case 'number': return 'number';
+        case 'boolean': return 'boolean';
+        case 'any': return 'any';
+        case 'array':
+            return node.items ? `Array<${idlTypeNodeToTs(node.items, indent)}>` : 'any[]';
+        case 'object':
+            if (node.fields && Object.keys(node.fields).length > 0) {
+                return objectShape(node.fields, indent);
+            }
+            return 'Record<string, any>';
+        case 'relation':
+            // When used as a standalone type (not as a field entry),
+            // a relation is a UUID string.
+            return 'string';
+        default:
+            // NamedRef or unknown — treat as any
+            return 'any';
+    }
+}
+const I = '  '; // indent unit
+function objectShape(fields, indent = 0) {
+    const entries = Object.entries(fields);
+    // Keep short objects (≤3 simple fields) inline
+    if (entries.length <= 3 && entries.every(([, n]) => !n.fields && n.type !== 'object')) {
+        const props = entries.map(([key, node]) => {
+            const opt = node.required === false || node.required === undefined;
+            return `${key}${opt ? '?' : ''}: ${idlTypeNodeToTs(node, indent)}`;
+        });
+        return `{ ${props.join('; ')} }`;
+    }
+    const pad = I.repeat(indent + 1);
+    const closePad = I.repeat(indent);
+    const lines = entries.map(([key, node]) => {
+        const opt = node.required === false || node.required === undefined;
+        return `${pad}${key}${opt ? '?' : ''}: ${idlTypeNodeToTs(node, indent + 1)};`;
+    });
+    return `{\n${lines.join('\n')}\n${closePad}}`;
+}
+// ── Relation expansion ────────────────────────────────────────────────────────
+/**
+ * Expands a field map into TypeScript property lines. Relation fields produce
+ * two entries: the UUID field (`field: string`) and the hydrated reference
+ * (`field_RefObj: T` or `field_RefObj: Array<T>`).
+ */
+function expandFieldLines(fields, pad, indent) {
+    const lines = [];
+    for (const [k, node] of Object.entries(fields)) {
+        const opt = node.required === false || node.required === undefined;
+        if (node.type === 'relation') {
+            // UUID string field
+            lines.push(`${pad}${k}${opt ? '?' : ''}: string;`);
+            // Hydrated _RefObj field
+            const itemTs = node.items ? idlTypeNodeToTs(node.items, indent) : 'any';
+            const refType = node.cardinality === 'many' ? `Array<${itemTs}>` : itemTs;
+            lines.push(`${pad}${k}_RefObj?: ${refType};`);
+        }
+        else {
+            lines.push(`${pad}${k}${opt ? '?' : ''}: ${idlTypeNodeToTs(node, indent)};`);
+        }
+    }
+    return lines;
+}
+/**
+ * Like objectShape but expands relation fields into two properties.
+ */
+function objectShapeWithRelations(fields, indent = 0) {
+    const entries = Object.entries(fields);
+    const hasRelation = entries.some(([, n]) => n.type === 'relation');
+    if (!hasRelation)
+        return objectShape(fields, indent); // fast path
+    const pad = I.repeat(indent + 1);
+    const closePad = I.repeat(indent);
+    const lines = expandFieldLines(fields, pad, indent + 1);
+    return `{\n${lines.join('\n')}\n${closePad}}`;
+}
+// ── Top-level generators ──────────────────────────────────────────────────────
+function buildComponentModels(components, baseIndent) {
+    const entries = [];
+    const d = baseIndent;
+    const pad = I.repeat(d);
+    for (const [ref, comp] of Object.entries(components)) {
+        if (!comp)
+            continue;
+        // Collect all schema names from base + extensions.
+        const schemaNames = new Set();
+        for (const s of Object.keys(comp.schemas ?? {}))
+            schemaNames.add(s);
+        for (const ext of Object.values(comp.extensions ?? {})) {
+            if (!ext)
+                continue;
+            for (const s of Object.keys(ext.schemas ?? {}))
+                schemaNames.add(s);
+        }
+        for (const schema of schemaNames) {
+            const key = schema === 'default' ? ref : `${ref}.${schema}`;
+            const baseFields = comp.schemas?.[schema]?.fields;
+            // Collect extension entries for this schema.
+            const extEntries = [];
+            for (const [extName, ext] of Object.entries(comp.extensions ?? {})) {
+                if (!ext)
+                    continue;
+                const extSchemaFields = ext.schemas?.[schema]?.fields;
+                if (extSchemaFields && Object.keys(extSchemaFields).length > 0) {
+                    extEntries.push([extName, extSchemaFields]);
+                }
+            }
+            const hasBase = baseFields && Object.keys(baseFields).length > 0;
+            const hasExt = extEntries.length > 0;
+            if (!hasBase && !hasExt) {
+                entries.push(`${pad}${JSON.stringify(key)}: Record<string, any>;`);
+                continue;
+            }
+            const propLines = [];
+            if (hasBase) {
+                propLines.push(...expandFieldLines(baseFields, `${pad}${I}`, d + 1));
+            }
+            if (hasExt) {
+                const extInner = [];
+                for (const [extName, extFields] of extEntries) {
+                    extInner.push(`${pad}${I}${I}${extName}: ${objectShapeWithRelations(extFields, d + 2)};`);
+                }
+                propLines.push(`${pad}${I}extensions: {\n${extInner.join('\n')}\n${pad}${I}};`);
+            }
+            entries.push(`${pad}${JSON.stringify(key)}: {\n${propLines.join('\n')}\n${pad}};`);
+        }
+    }
+    if (entries.length === 0)
+        return '';
+    return entries.join('\n');
+}
+function buildComponentFunctions(components, baseIndent) {
+    const entries = [];
+    const d = baseIndent;
+    const pad = I.repeat(d);
+    for (const [ref, comp] of Object.entries(components)) {
+        if (!comp)
+            continue;
+        const allFunctions = [
+            ...(comp.functions ?? []),
+            ...Object.values(comp.extensions ?? {}).flatMap(ext => ext?.functions ?? []),
+        ];
+        if (allFunctions.length === 0)
+            continue;
+        const fnLines = [];
+        for (const fn of allFunctions) {
+            const parts = [];
+            if (fn.input && Object.keys(fn.input).length > 0)
+                parts.push(`input: ${objectShape(fn.input, d + 2)}`);
+            if (fn.output)
+                parts.push(`output: ${idlTypeNodeToTs(fn.output, d + 2)}`);
+            if (parts.length === 0)
+                continue;
+            fnLines.push(`${pad}${I}${JSON.stringify(fn.name)}: { ${parts.join('; ')} };`);
+        }
+        if (fnLines.length > 0)
+            entries.push(`${pad}${JSON.stringify(ref)}: {\n${fnLines.join('\n')}\n${pad}};`);
+    }
+    if (entries.length === 0)
+        return '';
+    return entries.join('\n');
+}
+function buildPlatformFunctions(functions, baseIndent) {
+    const entries = [];
+    const d = baseIndent;
+    const pad = I.repeat(d);
+    for (const [name, sig] of Object.entries(functions)) {
+        if (!sig)
+            continue;
+        const parts = [];
+        if (sig.input && Object.keys(sig.input).length > 0)
+            parts.push(`input: ${objectShape(sig.input, d + 1)}`);
+        if (sig.output)
+            parts.push(`output: ${idlTypeNodeToTs(sig.output, d + 1)}`);
+        if (parts.length === 0)
+            continue;
+        entries.push(`${pad}${JSON.stringify(name)}: { ${parts.join('; ')} };`);
+    }
+    if (entries.length === 0)
+        return '';
+    return entries.join('\n');
+}
+// ── Main export ───────────────────────────────────────────────────────────────
+/**
+ * Converts an IDL response into a `declare module "@ptkl/sdk"` augmentation
+ * block. Write the output to a `.d.ts` file and include it in your project
+ * (e.g., via `tsconfig.json` `"include"` or a triple-slash reference).
+ */
+export function idlToModuleAugmentation(idl) {
+    const hasComponents = idl.components && Object.keys(idl.components).length > 0;
+    const hasFunctions = idl.functions && Object.keys(idl.functions).length > 0;
+    if (!hasComponents && !hasFunctions) {
+        return `// No IDL definitions found — nothing to generate.\n`;
+    }
+    const date = new Date().toISOString().slice(0, 10);
+    const lines = [
+        `// Generated by ptkl generate-types on ${date}`,
+        `// Do not edit manually — re-run \`ptkl generate-types\` to refresh.`,
+        ``,
+        `import "@ptkl/sdk";`,
+        `import "@ptkl/sdk/beta";`,
+    ];
+    // Declare interfaces once globally, then extend into both modules.
+    const ifaceNames = [];
+    if (hasComponents) {
+        const models = buildComponentModels(idl.components, 1);
+        if (models) {
+            lines.push(``, `interface _CM {\n${models}\n}`);
+            ifaceNames.push('ComponentModels extends _CM');
+        }
+        const fns = buildComponentFunctions(idl.components, 1);
+        if (fns) {
+            lines.push(``, `interface _CF {\n${fns}\n}`);
+            ifaceNames.push('ComponentFunctions extends _CF');
+        }
+    }
+    if (hasFunctions) {
+        const platFns = buildPlatformFunctions(idl.functions, 1);
+        if (platFns) {
+            lines.push(``, `interface _PF {\n${platFns}\n}`);
+            ifaceNames.push('PlatformFunctions extends _PF');
+        }
+    }
+    if (ifaceNames.length > 0) {
+        const augBody = ifaceNames.map(n => `  interface ${n} {}`).join('\n');
+        lines.push(``, `declare module "@ptkl/sdk" {\n${augBody}\n}`, ``, `declare module "@ptkl/sdk/beta" {\n${augBody}\n}`);
+    }
+    lines.push(``);
+    return lines.join('\n');
+}

package/dist/lib/util.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import Api from '@ptkl/sdk';
+import { Platform } from '@ptkl/sdk';
 export default class Util {
     static profilePath = `${process.env.HOME}/.ptkl`;
     static fileName = "profiles.json";
@@ -69,6 +69,6 @@ export default class Util {
     }
     static getClientForProfile() {
         const profile = Util.getCurrentProfile();
-        return new Api({ project: profile.project, token: profile.token, host: profile.host });
+        return new Platform({ project: profile.project, token: profile.token, host: profile.host });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ptkl/toolkit",
-  "version": "0.8.0",
+  "version": "0.8.12",
   "description": "A command-line toolkit for managing Protokol platform applications, profiles, functions, and components",
   "keywords": [
     "protokol",
@@ -35,7 +35,7 @@
     "@babel/preset-typescript": "^7.28.5",
     "@babel/standalone": "^7.26.10",
     "@inquirer/password": "^4.0.21",
-    "@ptkl/sdk": "^0.9.12",
+    "@ptkl/sdk": "^1.5.1",
     "@rollup/plugin-babel": "^6.1.0",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-node-resolve": "^16.0.3",

package/dist/builder/sdk5/webcomponents.js

@@ -1,38 +0,0 @@
-import * as Babel from '@babel/standalone';
-import less from 'less';
-export default class Compiler {
-    async compileBabel(expression) {
-        let code = Babel.transform(expression, {
-            sourceType: "module",
-            presets: ["env"]
-        });
-        return code.code;
-    }
-    async compileCSS(scope, lang, expression) {
-        switch (lang) {
-            case 'less':
-                if (scope) {
-                    return await less.render(`.${scope} { ${expression} }`);
-                }
-                const { css } = await less.render(`${expression}`);
-                return css;
-            default:
-                return expression;
-        }
-    }
-    async compile(ext, content) {
-        switch (ext) {
-            case 'js':
-                return await this.compileBabel(content);
-            case 'css':
-                return await this.compileCSS(null, "css", content);
-            case 'less':
-                return await this.compileCSS(null, "less", content);
-            default:
-                return await Promise.resolve(content);
-        }
-    }
-    getSupportedExt() {
-        return ["js", "css", "less", "json", "svg", "html"];
-    }
-}

package/dist/lib/importMapGenerator.js

@@ -1,96 +0,0 @@
-/**
- * Utility to generate import maps for component frameworks
- * This should be used on the frontend to dynamically create import maps
- * based on sdk_version and sdk_engine
- */
-/**
- * Generate an import map configuration for a given framework
- *
- * @param sdkEngine - The engine string (e.g., "react@18", "lit@3", "vue3")
- * @returns Import map configuration object
- *
- * @example
- * ```typescript
- * const importMap = generateImportMap("react@18");
- * // Inject into HTML:
- * const script = document.createElement('script');
- * script.type = 'importmap';
- * script.textContent = JSON.stringify(importMap);
- * document.head.appendChild(script);
- * ```
- */
-export function generateImportMap(sdkEngine) {
-    // Parse engine to extract framework and version (e.g., "lit@3" -> { framework: "lit", version: "3" })
-    const engineMatch = sdkEngine.match(/^([^@]+)(?:@(.+))?$/);
-    const framework = engineMatch ? engineMatch[1] : sdkEngine;
-    const frameworkVersion = engineMatch ? engineMatch[2] : null;
-    const imports = {};
-    if (framework === 'react') {
-        const version = frameworkVersion || '18';
-        imports['react'] = `https://esm.sh/react@${version}`;
-        imports['react-dom'] = `https://esm.sh/react-dom@${version}`;
-        imports['react/jsx-runtime'] = `https://esm.sh/react@${version}/jsx-runtime`;
-        imports['react/jsx-dev-runtime'] = `https://esm.sh/react@${version}/jsx-dev-runtime`;
-    }
-    else if (framework === 'vue3' || framework === 'vue') {
-        const version = frameworkVersion || '3';
-        imports['vue'] = `https://esm.sh/vue@${version}`;
-    }
-    else if (framework === 'lit') {
-        const version = frameworkVersion || '3';
-        imports['lit'] = `https://esm.sh/lit@${version}`;
-        imports['lit/decorators.js'] = `https://esm.sh/lit@${version}/decorators.js`;
-        imports['lit/directive.js'] = `https://esm.sh/lit@${version}/directive.js`;
-        imports['lit/directives/class-map.js'] = `https://esm.sh/lit@${version}/directives/class-map.js`;
-        imports['lit/directives/style-map.js'] = `https://esm.sh/lit@${version}/directives/style-map.js`;
-        imports['lit/directives/if-defined.js'] = `https://esm.sh/lit@${version}/directives/if-defined.js`;
-        imports['lit/directives/repeat.js'] = `https://esm.sh/lit@${version}/directives/repeat.js`;
-        imports['lit/directives/unsafe-html.js'] = `https://esm.sh/lit@${version}/directives/unsafe-html.js`;
-    }
-    else if (framework === 'webcomponents') {
-        // For vanilla web components, no external framework needed
-        return { imports: {} };
-    }
-    return { imports };
-}
-/**
- * Generate the import map HTML script tag as a string
- *
- * @param sdkEngine - The engine string (e.g., "react@18", "lit@3", "vue3")
- * @returns HTML string for the import map script tag
- *
- * @example
- * ```typescript
- * const scriptTag = generateImportMapHTML("react@18");
- * document.head.insertAdjacentHTML('beforeend', scriptTag);
- * ```
- */
-export function generateImportMapHTML(sdkEngine) {
-    const importMap = generateImportMap(sdkEngine);
-    if (Object.keys(importMap.imports).length === 0) {
-        return ''; // No import map needed
-    }
-    return `<script type="importmap">\n${JSON.stringify(importMap, null, 2)}\n</script>`;
-}
-/**
- * Inject import map into the document dynamically
- *
- * @param sdkEngine - The engine string (e.g., "react@18", "lit@3", "vue3")
- *
- * @example
- * ```typescript
- * // In your frontend code:
- * injectImportMap("react@18");
- * // Now you can load component modules
- * ```
- */
-export function injectImportMap(sdkEngine) {
-    const importMap = generateImportMap(sdkEngine);
-    if (Object.keys(importMap.imports).length === 0) {
-        return; // No import map needed
-    }
-    const script = document.createElement('script');
-    script.type = 'importmap';
-    script.textContent = JSON.stringify(importMap, null, 2);
-    document.head.appendChild(script);
-}