@powerhousedao/ph-clint-cli 0.1.0-dev.3 → 0.1.0-dev.30

package/dist/spec/from-document.d.ts

@@ -15,4 +15,7 @@ import { type ClintProjectSpec } from './types.js';
  * Returns `null` if the document has no valid package name yet — callers
  * should wait for the user to populate it before triggering codegen.
  */
-export declare function specFromDocumentState(state: PhClintProjectGlobalState): ClintProjectSpec | null;
+export declare function specFromDocumentState(state: PhClintProjectGlobalState, meta?: {
+    documentId?: string;
+    documentType?: string;
+}): ClintProjectSpec | null;

package/dist/spec/from-document.js

@@ -5,14 +5,9 @@ import { clintProjectSpecSchema, } from './types.js';
  * Returns `null` if the document has no valid package name yet — callers
  * should wait for the user to populate it before triggering codegen.
  */
-export function specFromDocumentState(state) {
+export function specFromDocumentState(state, meta) {
     if (!state.name)
         return null;
-    // `documentTypes` is a forward-compatible field — older `ph-clint-project`
-    // document states don't declare it yet. Pull through if present, otherwise
-    // leave it to the schema default (`[]`). Codegen treats the empty list as
-    // "no registry entries" and emits an empty `defineRegistry([...])`.
-    const documentTypes = state.documentTypes ?? undefined;
     const parsed = clintProjectSpecSchema.safeParse({
         name: state.name,
         scope: state.scope ?? undefined,
@@ -20,11 +15,26 @@ export function specFromDocumentState(state) {
         description: state.description,
         bin: state.bin ?? undefined,
         features: {
-            powerhouse: { ...state.features.powerhouse },
+            powerhouse: state.features.powerhouse,
             mastra: { ...state.features.mastra },
             routine: { ...state.features.routine },
         },
-        ...(Array.isArray(documentTypes) ? { documentTypes } : {}),
+        packages: state.packages.map((p) => ({
+            id: p.id,
+            packageName: p.packageName,
+            documentTypes: [...p.documentTypes],
+        })),
+        externalSkills: state.externalSkills.map((s) => ({
+            id: s.id,
+            name: s.name,
+            githubUrl: s.githubUrl,
+        })),
+        deployment: {
+            serviceAnnouncement: state.deployment.serviceAnnouncement,
+            supportedResources: [...state.deployment.supportedResources],
+        },
+        documentId: meta?.documentId,
+        documentType: meta?.documentType,
     });
     return parsed.success ? parsed.data : null;
 }

package/dist/spec/types.d.ts

@@ -9,6 +9,43 @@
  * generator step actually needs it.
  */
 import { z } from 'zod';
+/**
+ * Ordered Powerhouse integration level. Higher levels imply all lower ones:
+ *   Disabled → Reactor → Switchboard → Connect
+ */
+export declare const POWERHOUSE_LEVELS: readonly ["Disabled", "Reactor", "Switchboard", "Connect"];
+export declare const powerhouseLevelSchema: z.ZodDefault<z.ZodEnum<{
+    Disabled: "Disabled";
+    Reactor: "Reactor";
+    Switchboard: "Switchboard";
+    Connect: "Connect";
+}>>;
+export type PowerhouseLevel = z.infer<typeof powerhouseLevelSchema>;
+/** Check whether `level` is at least `threshold` in the ordered enum. */
+export declare function phAtLeast(level: PowerhouseLevel, threshold: PowerhouseLevel): boolean;
+export declare const agentModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    isDefault: z.ZodBoolean;
+}, z.core.$strip>;
+export type AgentModel = z.infer<typeof agentModelSchema>;
+export declare const agentProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type AgentProfile = z.infer<typeof agentProfileSchema>;
+export declare const powerhousePackageSchema: z.ZodObject<{
+    id: z.ZodString;
+    packageName: z.ZodString;
+    documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PowerhousePackage = z.infer<typeof powerhousePackageSchema>;
+export declare const externalSkillSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    githubUrl: z.ZodString;
+}, z.core.$strip>;
+export type ExternalSkill = z.infer<typeof externalSkillSchema>;
 export declare const clintProjectSpecSchema: z.ZodObject<{
     name: z.ZodString;
     scope: z.ZodOptional<z.ZodString>;
@@ -16,19 +53,48 @@ export declare const clintProjectSpecSchema: z.ZodObject<{
     description: z.ZodDefault<z.ZodString>;
     bin: z.ZodOptional<z.ZodString>;
     features: z.ZodDefault<z.ZodObject<{
-        powerhouse: z.ZodDefault<z.ZodObject<{
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            switchboard: z.ZodDefault<z.ZodBoolean>;
-            connect: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>>;
+        powerhouse: z.ZodDefault<z.ZodEnum<{
+            Disabled: "Disabled";
+            Reactor: "Reactor";
+            Switchboard: "Switchboard";
+            Connect: "Connect";
+        }>>;
         mastra: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
+            agentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            agentName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            agentDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            agentImage: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            models: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                isDefault: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            profiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                content: z.ZodString;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>;
         routine: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
-    documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    packages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        packageName: z.ZodString;
+        documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    externalSkills: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        githubUrl: z.ZodString;
+    }, z.core.$strip>>>;
+    deployment: z.ZodDefault<z.ZodObject<{
+        serviceAnnouncement: z.ZodDefault<z.ZodBoolean>;
+        supportedResources: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    documentId: z.ZodOptional<z.ZodString>;
+    documentType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ClintProjectSpec = z.infer<typeof clintProjectSpecSchema>;
 export type ClintProjectSpecInput = z.input<typeof clintProjectSpecSchema>;
@@ -45,6 +111,19 @@ export declare function getCliFolderName(spec: ClintProjectSpec): string;
  * Name of the reactor-package sub-folder when the project is split.
  */
 export declare function getAppFolderName(spec: ClintProjectSpec): string;
+/**
+ * Flat list of all document types across all packages. Convenience for
+ * codegen that needs to iterate every registered document type regardless
+ * of which package provides it.
+ */
+export declare function getAllDocumentTypes(spec: ClintProjectSpec): string[];
+/**
+ * The app npm package name (`@scope/{name}-app` or `{name}-app`).
+ * Matches what the document model reducer stores in `packages[].packageName`.
+ */
+export declare function getAppPackageName(spec: ClintProjectSpec): string;
+/** Directory name for the app package (`{name}-app`, no scope prefix). */
+export declare function getAppDirName(spec: ClintProjectSpec): string;
 /**
  * Folder slug for a documentType ID. The slug is the portion after the last
  * `/` (e.g. `powerhouse/ph-clint-project` → `ph-clint-project`). Matches the

package/dist/spec/types.js

@@ -9,29 +9,64 @@
  * generator step actually needs it.
  */
 import { z } from 'zod';
-const powerhouseFeatureSchema = z.object({
-    enabled: z.boolean().default(false),
-    switchboard: z.boolean().default(true),
-    connect: z.boolean().default(true),
+/**
+ * Ordered Powerhouse integration level. Higher levels imply all lower ones:
+ *   Disabled → Reactor → Switchboard → Connect
+ */
+export const POWERHOUSE_LEVELS = [
+    'Disabled',
+    'Reactor',
+    'Switchboard',
+    'Connect',
+];
+export const powerhouseLevelSchema = z
+    .enum(POWERHOUSE_LEVELS)
+    .default('Disabled');
+/** Check whether `level` is at least `threshold` in the ordered enum. */
+export function phAtLeast(level, threshold) {
+    return (POWERHOUSE_LEVELS.indexOf(level) >= POWERHOUSE_LEVELS.indexOf(threshold));
+}
+export const agentModelSchema = z.object({
+    id: z.string(),
+    isDefault: z.boolean(),
+});
+export const agentProfileSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    content: z.string(),
 });
 const mastraFeatureSchema = z.object({
     enabled: z.boolean().default(false),
+    agentId: z.string().nullable().default(null),
+    agentName: z.string().nullable().default(null),
+    agentDescription: z.string().nullable().default(null),
+    agentImage: z.string().nullable().default(null),
+    models: z.array(agentModelSchema).default([]),
+    profiles: z.array(agentProfileSchema).default([]),
 });
 const routineFeatureSchema = z.object({
     enabled: z.boolean().default(false),
 });
-// Zod 4 does not cascade `.default({})` through nested object schemas — a
-// missing outer key fills in `{}`, but nested keys with their own `.default`
-// are not re-defaulted unless the object itself re-parses. We spell out full
-// defaults here so `clintProjectSpecSchema.parse({ name: 'x' })` yields a
-// fully-populated feature tree.
-const DEFAULT_POWERHOUSE = {
+const DEFAULT_MASTRA = {
     enabled: false,
-    switchboard: true,
-    connect: true,
+    agentId: null,
+    agentName: null,
+    agentDescription: null,
+    agentImage: null,
+    models: [],
+    profiles: [],
 };
-const DEFAULT_MASTRA = { enabled: false };
 const DEFAULT_ROUTINE = { enabled: false };
+export const powerhousePackageSchema = z.object({
+    id: z.string(),
+    packageName: z.string(),
+    documentTypes: z.array(z.string()).default([]),
+});
+export const externalSkillSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    githubUrl: z.string(),
+});
 export const clintProjectSpecSchema = z.object({
     name: z
         .string()
@@ -40,29 +75,41 @@ export const clintProjectSpecSchema = z.object({
         .string()
         .regex(/^[a-z0-9][a-z0-9-]*$/, 'lowercase letters, digits, hyphens only')
         .optional(),
-    version: z.string().default('0.1.0'),
+    version: z.string().default('0.0.1-dev.0'),
     description: z.string().default(''),
     bin: z.string().optional(),
     features: z
         .object({
-        powerhouse: powerhouseFeatureSchema.default(DEFAULT_POWERHOUSE),
+        powerhouse: powerhouseLevelSchema,
         mastra: mastraFeatureSchema.default(DEFAULT_MASTRA),
         routine: routineFeatureSchema.default(DEFAULT_ROUTINE),
     })
         .default({
-        powerhouse: DEFAULT_POWERHOUSE,
+        powerhouse: 'Disabled',
         mastra: DEFAULT_MASTRA,
         routine: DEFAULT_ROUTINE,
     }),
     /**
-     * Document types registered with this CLI — full documentType ID strings
-     * (e.g. `powerhouse/ph-clint-project`). Drives codegen of `src/framework.gen.ts`,
-     * which emits a typed `defineRegistry([...] as const)` call so impl code
-     * gets narrowed `reactor.client.get(id, 'my-type')` access. Empty on
-     * fresh projects — populated as document models are added to the reactor
-     * package.
+     * Reactor packages and their document types. Each entry groups a package
+     * name with the document type IDs it provides. The app package (project's
+     * own reactor package) uses a `file:` dependency; external packages become
+     * versioned npm dependencies. Drives codegen of `framework.gen.ts`,
+     * `app/index.ts`, and `cli/package.json`.
      */
-    documentTypes: z.array(z.string()).default([]),
+    packages: z.array(powerhousePackageSchema).default([]),
+    /**
+     * External skills from the skills.sh ecosystem. Each skill has a name
+     * (kebab-case) and a GitHub URL for installation.
+     */
+    externalSkills: z.array(externalSkillSchema).default([]),
+    deployment: z.object({
+        serviceAnnouncement: z.boolean().default(false),
+        supportedResources: z.array(z.string()).default([]),
+    }).default({ serviceAnnouncement: false, supportedResources: [] }),
+    /** ID of the source specification document (if backed by a Powerhouse document). */
+    documentId: z.string().optional(),
+    /** Document type of the source specification document. */
+    documentType: z.string().optional(),
 });
 /** npm package name (e.g. `@scope/foo` or `foo`). */
 export function getPackageName(spec) {
@@ -85,6 +132,26 @@ export function getCliFolderName(spec) {
 export function getAppFolderName(spec) {
     return `${spec.name}-app`;
 }
+/**
+ * Flat list of all document types across all packages. Convenience for
+ * codegen that needs to iterate every registered document type regardless
+ * of which package provides it.
+ */
+export function getAllDocumentTypes(spec) {
+    return spec.packages.flatMap((p) => p.documentTypes);
+}
+/**
+ * The app npm package name (`@scope/{name}-app` or `{name}-app`).
+ * Matches what the document model reducer stores in `packages[].packageName`.
+ */
+export function getAppPackageName(spec) {
+    const base = `${spec.name}-app`;
+    return spec.scope ? `@${spec.scope}/${base}` : base;
+}
+/** Directory name for the app package (`{name}-app`, no scope prefix). */
+export function getAppDirName(spec) {
+    return `${spec.name}-app`;
+}
 /**
  * Folder slug for a documentType ID. The slug is the portion after the last
  * `/` (e.g. `powerhouse/ph-clint-project` → `ph-clint-project`). Matches the

package/dist/triggers/publish-trigger.d.ts

@@ -0,0 +1,10 @@
+/** Map document model PublishTag values to CLI --tag values. */
+export declare function tagToCli(tag: string): 'dev' | 'staging' | 'production' | null;
+export declare const publishTrigger: import("@powerhousedao/ph-clint").Trigger<{
+    pending: number;
+}, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    apiKey?: string | undefined;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;

package/dist/triggers/publish-trigger.js

@@ -0,0 +1,169 @@
+/**
+ * `publish-trigger` — watches ALL `powerhouse/ph-clint-project` documents for
+ * publish records with `Pending` status and invokes the publish pipeline.
+ *
+ * Unlike `spec-change`, this trigger does NOT convert to a `ClintProjectSpec`.
+ * It reads `publishHistory` directly from the document state, since publish
+ * records are a doc-model concern (not a codegen input).
+ *
+ * Uses the multi-doc path (no `documentId`), scanning all matching documents
+ * on each poll. For each document with a pending publish record, it uses the
+ * project mapping to resolve the on-disk project directory.
+ *
+ * Flow:
+ *   1. On document change, scans `publishHistory` for records with status
+ *      `"Pending"`.
+ *   2. For each pending record, returns a work item that:
+ *      a. Dispatches SET_PUBLISH_STATUS({ id, status: "InProgress" }).
+ *      b. Runs `ph-clint clint-project-publish --tag <tag>`.
+ *      c. Dispatches SET_PUBLISH_STATUS({ id, status: "Succeeded"|"Failed" }).
+ */
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { scanProjects, getProjectMapping } from '@powerhousedao/ph-clint';
+import { setPublishStatus } from '@powerhousedao/ph-clint-app';
+import { createDocumentChangeTrigger } from '../framework.js';
+import { specFromDocumentState } from '../spec/from-document.js';
+import { clintProject } from '../services/clint-project.js';
+const DOCUMENT_TYPE = 'powerhouse/ph-clint-project';
+const TAG = '[publish]';
+/** Run a shell command and return stdout. Rejects on non-zero exit. */
+function exec(cmd, args, cwd, onLog) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        const out = [];
+        const err = [];
+        proc.stdout?.on('data', (d) => {
+            const s = d.toString();
+            out.push(s);
+            if (onLog)
+                for (const line of s.split('\n'))
+                    if (line.trim())
+                        onLog(line.trim());
+        });
+        proc.stderr?.on('data', (d) => {
+            const s = d.toString();
+            err.push(s);
+            if (onLog)
+                for (const line of s.split('\n'))
+                    if (line.trim())
+                        onLog(line.trim());
+        });
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+            if (code === 0)
+                resolve(out.join(''));
+            else
+                reject(new Error(`${cmd} ${args.join(' ')} exited ${code}\n${err.join('')}`));
+        });
+    });
+}
+/** Map document model PublishTag values to CLI --tag values. */
+export function tagToCli(tag) {
+    switch (tag) {
+        case 'Dev':
+            return 'dev';
+        case 'Staging':
+            return 'staging';
+        case 'Production':
+            return 'production';
+        default:
+            return null;
+    }
+}
+export const publishTrigger = createDocumentChangeTrigger({
+    id: 'publish-trigger',
+    documentType: DOCUMENT_TYPE,
+    // No documentId → watches ALL ph-clint-project docs
+    // Don't fire on startup — only react to new pending records.
+    initialReconcile: false,
+    async onChange(docs, ctx) {
+        const log = ctx.context.log;
+        const folders = ctx.context.folders;
+        // Build the mapping to resolve on-disk project directories
+        const scanner = clintProject.projectScanner;
+        const scanResults = scanner
+            ? scanProjects(ctx.context.workdir, scanner)
+            : [];
+        const mapping = await getProjectMapping(scanResults, folders);
+        for (const doc of docs) {
+            const publishHistory = doc.state.global.publishHistory ?? [];
+            const pending = publishHistory.filter((r) => r.status === 'Pending');
+            if (pending.length === 0)
+                continue;
+            // Resolve the on-disk target directory for this document
+            const spec = specFromDocumentState(doc.state.global, {
+                documentId: doc.header.id,
+                documentType: doc.header.documentType,
+            });
+            const entry = mapping.find((m) => m.documentId === doc.header.id);
+            const workdir = entry?.path
+                ?? (spec ? path.join(ctx.context.workdir, spec.name) : ctx.context.workdir);
+            // Process the first pending record (one per tick to avoid races).
+            const record = pending[0];
+            const cliTag = tagToCli(record.tag);
+            if (!cliTag) {
+                log?.warn(`${TAG} unknown publish tag "${record.tag}" for record ${record.id}`);
+                continue;
+            }
+            log?.info(`${TAG} found pending ${record.tag} publish for doc ${doc.header.id} (id=${record.id}, version=${record.version})`);
+            return {
+                type: 'function',
+                params: {
+                    fn: async () => {
+                        const reactor = await ctx.reactor();
+                        if (!reactor) {
+                            log?.error(`${TAG} reactor not available, cannot update publish status`);
+                            return;
+                        }
+                        // Mark as InProgress.
+                        log?.info(`${TAG} marking record ${record.id} as InProgress`);
+                        await reactor.client.execute(doc.header.id, 'main', [
+                            setPublishStatus({ id: record.id, status: 'InProgress' }),
+                        ]);
+                        // Install dependencies in the generated project before publishing.
+                        log?.info(`${TAG} running pnpm install in ${workdir}`);
+                        try {
+                            await exec('pnpm', ['install'], workdir, (msg) => log?.debug(`${TAG} [install] ${msg}`));
+                        }
+                        catch (installErr) {
+                            log?.error(`${TAG} pnpm install failed: ${installErr instanceof Error ? installErr.message : String(installErr)}`);
+                        }
+                        // Run the publish command.
+                        let success = false;
+                        try {
+                            log?.info(`${TAG} invoking clint-project-publish --tag ${cliTag}`);
+                            const { clintProjectPublish } = await import('../commands/clint-project-publish.js');
+                            const result = await clintProjectPublish.execute({ tag: cliTag, dryRun: false, skipBuild: false, skipGitCheck: true, verbose: false }, 
+                            // @ts-expect-error — minimal context; publish uses workdir + stdout.
+                            {
+                                workdir,
+                                stdout: (msg) => log?.info(`${TAG} ${msg}`),
+                                log,
+                            });
+                            success = !result.text.includes('failed');
+                        }
+                        catch (err) {
+                            log?.error(`${TAG} publish failed: ${err instanceof Error ? err.message : String(err)}`);
+                        }
+                        // Update status.
+                        const finalStatus = success ? 'Succeeded' : 'Failed';
+                        log?.info(`${TAG} marking record ${record.id} as ${finalStatus}`);
+                        await reactor.client.execute(doc.header.id, 'main', [
+                            setPublishStatus({
+                                id: record.id,
+                                status: finalStatus,
+                            }),
+                        ]);
+                    },
+                },
+                callbacks: {
+                    onFailure: (err) => {
+                        log?.error(`${TAG} publish trigger failed: ${err.message}`);
+                    },
+                },
+            };
+        }
+        return null;
+    },
+});

package/dist/triggers/spec-change.d.ts

@@ -1,43 +1,14 @@
+import type { ImportSpecInput } from '@powerhousedao/ph-clint-app/document-models/ph-clint-project';
 import type { ClintProjectSpec } from '../spec/types.js';
-/** Stable hash of a ClintProjectSpec (sha256 of canonical-key JSON). */
+/** Stable hash of a ClintProjectSpec (sha256 of canonical-key JSON).
+ *  Excludes documentId/documentType — they don't affect codegen output. */
 export declare function hashSpec(spec: ClintProjectSpec): string;
+export declare function specToImportInput(spec: ClintProjectSpec): ImportSpecInput;
 export declare const specChangeTrigger: import("@powerhousedao/ph-clint").Trigger<{
     pending: number;
 }, {
     model: string;
     devServicePort: number;
     phVersion: string;
-    projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
-}, import("@powerhousedao/ph-clint").InferRegistry<readonly [{
-    readonly version: 1;
-    readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly actions: {
-        enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-        disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-        enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-        disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-        enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-        setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-        setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-        setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-        clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-        setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-        setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-        setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-        clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-        setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-        setName: (name: string | {
-            name: string;
-        }) => import("document-model").SetNameAction;
-        undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-        redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-        prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-        loadState: <TState extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState & {
-            name: string;
-        }, operations: number) => import("document-model").LoadStateAction;
-        noop: (scope?: string) => import("document-model").NOOPAction;
-    };
-    readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly documentModel: import("document-model").DocumentModelPHState;
-}]>>;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app/document-models/ph-clint-project").PhClintProjectPHState>]>>;