dominds 1.8.3 → 1.8.5

package/dist/access-control.d.ts

@@ -0,0 +1,46 @@
+import type { LanguageCode } from './shared/types/language';
+import { Team } from './team';
+/**
+ * Directory-specific pattern matching for access control.
+ * This function determines if a target path (file or directory) should be controlled
+ * by a directory pattern. The pattern represents a directory scope.
+ *
+ * Supports:
+ * - "*" matches any single directory/file name within a path segment
+ * - "**" matches any number of directory levels (including zero)
+ * - Exact directory matches
+ *
+ * Directory semantics:
+ * - Pattern "src" matches "src/file.txt", "src/subdir/file.js", etc.
+ * - Pattern "src" does NOT match "src-backup/file.txt" (prevents false positives)
+ * - Pattern "src/tools" matches "src/tools/fs.ts" but not "src/other/file.ts"
+ */
+export declare function matchesPattern(targetPath: string, dirPattern: string): boolean;
+/**
+ * Check if a member has read access to a specific path.
+ *
+ * Access control logic:
+ * 1. Check blacklist first (no_read_dirs) - if path matches any blacklist pattern, deny access
+ * 2. Check whitelist (read_dirs) - if path matches any whitelist pattern, allow access
+ * 3. Check extension blacklist (no_read_file_ext_names) - if extension matches, deny access
+ * 4. Check extension whitelist (read_file_ext_names)
+ * 5. If no whitelist patterns are defined for a dimension, allow access (default allow)
+ * 6. If whitelist patterns exist but none match, deny access
+ */
+export declare function hasReadAccess(member: Team.Member, targetPath: string): boolean;
+/**
+ * Check if a member has write access to a specific path.
+ *
+ * Access control logic:
+ * 1. Check blacklist first (no_write_dirs) - if path matches any blacklist pattern, deny access
+ * 2. Check whitelist (write_dirs) - if path matches any whitelist pattern, allow access
+ * 3. Check extension blacklist (no_write_file_ext_names) - if extension matches, deny access
+ * 4. Check extension whitelist (write_file_ext_names)
+ * 5. If no whitelist patterns are defined for a dimension, allow access (default allow)
+ * 6. If whitelist patterns exist but none match, deny access
+ */
+export declare function hasWriteAccess(member: Team.Member, targetPath: string): boolean;
+/**
+ * Get an access denied error message for a specific operation and path.
+ */
+export declare function getAccessDeniedMessage(operation: 'read' | 'write', targetPath: string, language?: LanguageCode): string;

package/dist/apps/app-id.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeDomindsAppId(value: string): string;
+export declare function isValidDomindsAppId(value: string): boolean;
+export declare function domindsAppIdToPathParts(appId: string): ReadonlyArray<string>;
+export declare function resolveDomindsAppRtwsDirAbs(rtwsRootAbs: string, appId: string): string;
+export declare function resolveDomindsAppLocalPackageRootAbs(rootAbs: string, appId: string): string;
+export declare function formatDomindsAppRtwsDirRel(appId: string): string;

package/dist/apps/app-json.d.ts

@@ -0,0 +1,127 @@
+import type { I18nText } from '../shared/types/i18n';
+import type { JsonSchema, JsonValue, ReminderUpdateResult, ToolArguments, ToolCallOutput } from '../tool';
+export type DomindsAppJsonSchemaVersion = 1;
+export type DomindsAppToolJson = Readonly<{
+    name: string;
+    description?: string;
+    descriptionI18n?: I18nText;
+    parameters: JsonSchema;
+}>;
+export type DomindsAppToolsetJson = Readonly<{
+    id: string;
+    descriptionI18n?: I18nText;
+    tools: ReadonlyArray<DomindsAppToolJson>;
+}>;
+export type DomindsAppDialogRunControlJson = Readonly<{
+    id: string;
+    descriptionI18n?: I18nText;
+}>;
+export type DomindsAppReminderOwnerJson = Readonly<{
+    ref: string;
+    managedByTool?: string;
+    updateExample?: string;
+}>;
+export type DomindsAppContributesJson = Readonly<{
+    teammatesYamlRelPath?: string;
+    toolsets?: ReadonlyArray<DomindsAppToolsetJson>;
+    dialogRunControls?: ReadonlyArray<DomindsAppDialogRunControlJson>;
+    reminderOwners?: ReadonlyArray<DomindsAppReminderOwnerJson>;
+}>;
+export type DomindsAppHostEntryJson = Readonly<{
+    kind: 'node_module';
+    moduleRelPath: string;
+    exportName: string;
+}>;
+export type DomindsAppFrontendJson = Readonly<{
+    kind: 'http';
+    defaultPort?: number;
+    basePath?: string;
+    wsPath?: string;
+}>;
+/**
+ * The JSON payload printed by `npx <pkg> --dominds-app` for Dominds app installation and runtime.
+ * This JSON is treated as the stable handshake between dominds kernel and a Dominds App package.
+ */
+export type DomindsAppInstallJsonV1 = Readonly<{
+    schemaVersion: DomindsAppJsonSchemaVersion;
+    appId: string;
+    displayName?: string;
+    package: Readonly<{
+        name: string;
+        version: string | null;
+        rootAbs: string;
+    }>;
+    host: DomindsAppHostEntryJson;
+    frontend?: DomindsAppFrontendJson;
+    contributes?: DomindsAppContributesJson;
+}>;
+export declare function parseDomindsAppInstallJson(v: unknown): {
+    ok: true;
+    json: DomindsAppInstallJsonV1;
+} | {
+    ok: false;
+    errorText: string;
+};
+export type DomindsAppHostToolContext = Readonly<{
+    dialogId: string;
+    rootDialogId: string;
+    agentId: string;
+    taskDocPath: string;
+    sessionSlug?: string;
+    callerId: string;
+}>;
+export type DomindsAppDialogTargetRef = Readonly<{
+    dialogId: string;
+} | {
+    rootDialogId?: string;
+    agentId: string;
+    sessionSlug?: string;
+}>;
+export type DomindsAppDialogInfo = Readonly<{
+    dialogId: string;
+    rootDialogId: string;
+    agentId: string;
+    sessionSlug?: string;
+}>;
+export type DomindsAppReminderState = Readonly<{
+    content: string;
+    meta?: JsonValue;
+    echoback?: boolean;
+}>;
+export type DomindsAppReminderApplyRequest = Readonly<{
+    kind: 'upsert';
+    ownerRef: string;
+    content: string;
+    meta?: JsonValue;
+    position?: number;
+    echoback?: boolean;
+} | {
+    kind: 'delete';
+    ownerRef: string;
+    meta?: JsonValue;
+}>;
+export type DomindsAppReminderApplyResult = Readonly<{
+    treatment: 'noop';
+} | {
+    treatment: 'add';
+    reminder: DomindsAppReminderState;
+    position?: number;
+} | {
+    treatment: 'update';
+    ownedIndex: number;
+    reminder: DomindsAppReminderState;
+} | {
+    treatment: 'delete';
+    ownedIndex: number;
+}>;
+export type DomindsAppDialogReminderRequestBatch = Readonly<{
+    target: DomindsAppDialogTargetRef;
+    reminderRequests: ReadonlyArray<DomindsAppReminderApplyRequest>;
+}>;
+export type DomindsAppHostToolResult = Readonly<{
+    output: ToolCallOutput;
+    reminderRequests?: ReadonlyArray<DomindsAppReminderApplyRequest>;
+    dialogReminderRequests?: ReadonlyArray<DomindsAppDialogReminderRequestBatch>;
+}>;
+export type DomindsAppHostToolHandler = (args: ToolArguments, ctx: DomindsAppHostToolContext) => Promise<ToolCallOutput | DomindsAppHostToolResult>;
+export type DomindsAppHostReminderUpdateResult = ReminderUpdateResult;

package/dist/apps/app-lock-file.d.ts

@@ -0,0 +1,45 @@
+export type AppLockSchemaVersion = 1;
+export type AppLockEntry = Readonly<{
+    id: string;
+    package: Readonly<{
+        name: string;
+        version: string | null;
+    }>;
+}>;
+export type AppLockFile = Readonly<{
+    schemaVersion: AppLockSchemaVersion;
+    apps: ReadonlyArray<AppLockEntry>;
+}>;
+export declare const APP_LOCK_REL_PATH: string;
+export declare function parseAppLockFile(parsed: unknown, filePathAbs: string): {
+    ok: true;
+    file: AppLockFile;
+} | {
+    ok: false;
+    errorText: string;
+};
+export declare function loadAppLockFile(params: {
+    rtwsRootAbs: string;
+}): Promise<Readonly<{
+    kind: 'ok';
+    file: AppLockFile;
+    filePathAbs: string;
+    exists: boolean;
+}> | Readonly<{
+    kind: 'error';
+    errorText: string;
+    filePathAbs: string;
+}>>;
+export declare function findLockedApp(file: AppLockFile, appId: string): AppLockEntry | null;
+export declare function upsertLockedApp(params: {
+    existing: AppLockFile;
+    next: AppLockEntry;
+}): AppLockFile;
+export declare function removeLockedApp(params: {
+    existing: AppLockFile;
+    appId: string;
+}): AppLockFile;
+export declare function writeAppLockFileIfChanged(params: {
+    rtwsRootAbs: string;
+    file: AppLockFile;
+}): Promise<void>;

package/dist/apps/assigned-port.d.ts

@@ -0,0 +1,28 @@
+import type { DomindsAppInstallJsonV1 } from './app-json';
+import type { AppsResolutionEntry } from './resolution-file';
+export type AssignedPortResolutionReason = 'no_frontend' | 'kept_existing' | 'selected_default' | 'allocated_stable_range' | 'reassigned_from_existing_conflict' | 'reassigned_from_existing_unbindable';
+export type AssignedPortResolution = Readonly<{
+    assignedPort: number | null;
+    reason: AssignedPortResolutionReason;
+}>;
+/**
+ * Resolve a stable non-zero assignedPort for an app frontend.
+ *
+ * - If the app has no frontend, returns null.
+ * - If an existing assignedPort exists, keeps it when still valid/bindable.
+ * - If existing assignedPort collides or is not bindable, reassigns deterministically.
+ * - Otherwise, tries installJson.frontend.defaultPort when it is bindable.
+ * - Falls back to a deterministic stable-range allocator.
+ */
+export declare function resolveStableAssignedPort(params: {
+    appId: string;
+    installJson: DomindsAppInstallJsonV1;
+    existingApps: ReadonlyArray<AppsResolutionEntry>;
+    existingAssignedPort: number | null;
+}): Promise<number | null>;
+export declare function resolveStableAssignedPortWithReason(params: {
+    appId: string;
+    installJson: DomindsAppInstallJsonV1;
+    existingApps: ReadonlyArray<AppsResolutionEntry>;
+    existingAssignedPort: number | null;
+}): Promise<AssignedPortResolution>;

package/dist/apps/configuration-file.d.ts

@@ -0,0 +1,51 @@
+export type AppsResolutionStrategyOrderItem = 'local' | 'npx';
+export type AppsResolutionStrategy = Readonly<{
+    order?: ReadonlyArray<AppsResolutionStrategyOrderItem>;
+    localRoots?: ReadonlyArray<string>;
+}>;
+export declare const DEFAULT_APPS_RESOLUTION_STRATEGY: AppsResolutionStrategy;
+export type NormalizedAppsResolutionStrategy = Readonly<{
+    order: ReadonlyArray<AppsResolutionStrategyOrderItem>;
+    localRoots: ReadonlyArray<string>;
+}>;
+export type AppsConfigurationSchemaVersion = 1;
+export type AppsConfigurationFile = Readonly<{
+    schemaVersion: AppsConfigurationSchemaVersion;
+    resolutionStrategy?: AppsResolutionStrategy;
+    disabledApps?: ReadonlyArray<string>;
+}>;
+export declare const APPS_CONFIGURATION_REL_PATH: string;
+export declare function parseResolutionStrategy(v: unknown, at: string): {
+    ok: true;
+    strategy: AppsResolutionStrategy;
+} | {
+    ok: false;
+    errorText: string;
+};
+export declare function normalizeAppsResolutionStrategy(raw: AppsResolutionStrategy | undefined): NormalizedAppsResolutionStrategy;
+export declare function loadAppsConfigurationFile(params: {
+    rtwsRootAbs: string;
+}): Promise<Readonly<{
+    kind: 'ok';
+    file: AppsConfigurationFile;
+    filePathAbs: string;
+    exists: boolean;
+}> | Readonly<{
+    kind: 'error';
+    errorText: string;
+    filePathAbs: string;
+}>>;
+export declare function writeAppsConfigurationFile(params: {
+    rtwsRootAbs: string;
+    file: AppsConfigurationFile;
+}): Promise<void>;
+export declare function writeAppsConfigurationFileIfChanged(params: {
+    rtwsRootAbs: string;
+    file: AppsConfigurationFile;
+}): Promise<void>;
+export declare function isAppDisabledInConfiguration(file: AppsConfigurationFile, appId: string): boolean;
+export declare function setAppDisabledInConfiguration(params: {
+    existing: AppsConfigurationFile;
+    appId: string;
+    disabled: boolean;
+}): AppsConfigurationFile;

package/dist/apps/dialog-run-controls.d.ts

@@ -0,0 +1,16 @@
+import type { I18nText } from '../shared/types/i18n';
+export type AppDialogRunControlMeta = Readonly<{
+    appId: string;
+    descriptionI18n?: I18nText;
+}>;
+export declare function clearAppDialogRunControlsRegistry(): void;
+export declare function registerAppDialogRunControl(params: {
+    id: string;
+    appId: string;
+    descriptionI18n?: I18nText;
+}): void;
+export declare function unregisterAppDialogRunControl(id: string): void;
+export declare function getAppDialogRunControlMeta(id: string): AppDialogRunControlMeta | null;
+export declare function listAppDialogRunControls(): ReadonlyArray<Readonly<{
+    id: string;
+} & AppDialogRunControlMeta>>;

package/dist/apps/enabled-apps.d.ts

@@ -0,0 +1,35 @@
+import { type AppsResolutionEntry, type AppsResolutionFile } from './resolution-file';
+export type EnabledAppSnapshotEntry = Readonly<{
+    id: string;
+    runtimePort: number | null;
+    installJson: AppsResolutionEntry['installJson'];
+    source: AppsResolutionEntry['source'];
+}>;
+export type AppsResolutionIssue = Readonly<{
+    kind: 'required_dependency_missing' | 'required_dependency_disabled' | 'app_manifest_load_failed' | 'app_effectively_disabled_due_to_required_dependency' | 'assigned_port_reassigned';
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    detail: Readonly<Record<string, unknown>>;
+}>;
+export type EnabledAppsSnapshot = Readonly<{
+    enabledApps: ReadonlyArray<EnabledAppSnapshotEntry>;
+    issues: ReadonlyArray<AppsResolutionIssue>;
+}>;
+type ResolvedGraphState = Readonly<{
+    resolutionFile: AppsResolutionFile;
+    issues: ReadonlyArray<AppsResolutionIssue>;
+}>;
+export type AppsResolutionMaterializationResult = Readonly<{
+    resolved: ResolvedGraphState;
+    wroteResolutionFile: boolean;
+}>;
+export declare function resolveAppsGraphState(params: {
+    rtwsRootAbs: string;
+}): Promise<ResolvedGraphState>;
+export declare function materializeAppsResolution(params: {
+    rtwsRootAbs: string;
+}): Promise<AppsResolutionMaterializationResult>;
+export declare function loadEnabledAppsSnapshot(params: {
+    rtwsRootAbs: string;
+}): Promise<EnabledAppsSnapshot>;
+export {};

package/dist/apps/enabled-apps.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAppsGraphState = resolveAppsGraphState;
 exports.materializeAppsResolution = materializeAppsResolution;
 exports.loadEnabledAppsSnapshot = loadEnabledAppsSnapshot;
 const node_path_1 = __importDefault(require("node:path"));
@@ -353,7 +354,7 @@ async function resolveGraph(params) {
         issues,
     };
 }
-async function materializeAppsResolution(params) {
+async function resolveAppsGraphState(params) {
     const loadedConfig = await (0, configuration_file_1.loadAppsConfigurationFile)({ rtwsRootAbs: params.rtwsRootAbs });
     if (loadedConfig.kind === 'error') {
         throw new Error(`Failed to load apps configuration: ${loadedConfig.errorText} (${loadedConfig.filePathAbs})`);
@@ -382,16 +383,25 @@ async function materializeAppsResolution(params) {
         lockedHintsById,
         hasConfigurationFile: loadedConfig.exists,
     });
+    return resolved;
+}
+async function materializeAppsResolution(params) {
+    const loadedResolution = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs: params.rtwsRootAbs });
+    if (loadedResolution.kind === 'error') {
+        throw new Error(`Failed to load apps resolution snapshot: ${loadedResolution.errorText} (${loadedResolution.filePathAbs})`);
+    }
+    const resolved = await resolveAppsGraphState({ rtwsRootAbs: params.rtwsRootAbs });
     if (JSON.stringify(loadedResolution.file) !== JSON.stringify(resolved.resolutionFile)) {
         await (0, resolution_file_1.writeAppsResolutionFileIfChanged)({
             rtwsRootAbs: params.rtwsRootAbs,
             file: resolved.resolutionFile,
         });
+        return { resolved, wroteResolutionFile: true };
     }
-    return resolved;
+    return { resolved, wroteResolutionFile: false };
 }
 async function loadEnabledAppsSnapshot(params) {
-    const resolved = await materializeAppsResolution({ rtwsRootAbs: params.rtwsRootAbs });
+    const { resolved } = await materializeAppsResolution({ rtwsRootAbs: params.rtwsRootAbs });
     return {
         enabledApps: resolved.resolutionFile.apps
             .filter((app) => app.enabled)

package/dist/apps/local-package-root.d.ts

@@ -0,0 +1,7 @@
+import type { AppsResolutionEntry } from './resolution-file';
+export declare function resolveLocalAppPackageRootAbs(params: {
+    rtwsRootAbs: string;
+    appId: string;
+    localRoots: ReadonlyArray<string>;
+    previousResolutionEntry: AppsResolutionEntry | null;
+}): Promise<string | null>;

package/dist/apps/manifest.d.ts

@@ -0,0 +1,101 @@
+export type DomindsAppManifest = Readonly<{
+    apiVersion: 'dominds.io/v1alpha1';
+    kind: 'DomindsApp';
+    id: string;
+    dependencies?: ReadonlyArray<DomindsAppDependency>;
+    name?: Readonly<{
+        zh?: string;
+        en?: string;
+    }>;
+    description?: Readonly<{
+        zh?: string;
+        en?: string;
+    }>;
+    contributes?: Readonly<{
+        web?: Readonly<{
+            staticDir: string;
+            mountPath?: string;
+        }>;
+        teammates?: Readonly<{
+            teamYaml: string;
+        }>;
+        tools?: Readonly<{
+            module: string;
+        }>;
+        rtwsSeed?: Readonly<{
+            taskdocs?: ReadonlyArray<Readonly<{
+                path: string;
+                goals?: string;
+                constraints?: string;
+                progress?: string;
+            }>>;
+        }>;
+    }>;
+}>;
+export type DomindsAppDependency = Readonly<{
+    id: string;
+    optional?: boolean;
+}>;
+export type AppManifestLoadResult = Readonly<{
+    kind: 'ok';
+    manifest: DomindsAppManifest;
+    raw: string;
+    filePathAbs: string;
+}> | Readonly<{
+    kind: 'error';
+    errorText: string;
+    filePathAbs: string;
+}>;
+export declare const DEFAULT_DOMINDS_APP_MANIFEST_REL_PATH = ".minds/app.yaml";
+export declare function makeDefaultRtwsAppManifest(id?: string): DomindsAppManifest;
+export declare function parseDomindsAppManifest(parsed: unknown, filePathAbs: string): {
+    ok: true;
+    manifest: DomindsAppManifest;
+} | {
+    ok: false;
+    errorText: string;
+};
+export declare function loadDomindsAppManifest(params: {
+    packageRootAbs: string;
+    manifestRelPath: string;
+}): Promise<AppManifestLoadResult>;
+export declare function writeDomindsAppManifest(params: {
+    packageRootAbs: string;
+    manifestRelPath: string;
+    manifest: DomindsAppManifest;
+}): Promise<void>;
+export declare function writeDomindsAppManifestIfChanged(params: {
+    packageRootAbs: string;
+    manifestRelPath: string;
+    manifest: DomindsAppManifest;
+}): Promise<void>;
+export declare function loadRtwsDeclaredAppDependencies(params: {
+    rtwsRootAbs: string;
+}): Promise<ReadonlyArray<DomindsAppDependency>>;
+export declare function hasRtwsDeclaredAppDependency(params: {
+    rtwsRootAbs: string;
+    appId: string;
+}): Promise<boolean>;
+export declare function upsertManifestDependency(params: {
+    manifest: DomindsAppManifest;
+    dependency: DomindsAppDependency;
+}): DomindsAppManifest;
+export declare function removeManifestDependency(params: {
+    manifest: DomindsAppManifest;
+    dependencyId: string;
+}): DomindsAppManifest;
+export declare function resolveAppContribPaths(params: {
+    manifest: DomindsAppManifest;
+    packageRootAbs: string;
+}): Readonly<{
+    webStaticDirAbs: string | null;
+    webMountPath: string | null;
+    teammatesYamlAbs: string | null;
+    toolsModuleAbs: string | null;
+    seedTaskdocs: ReadonlyArray<Readonly<{
+        path: string;
+        goals?: string;
+        constraints?: string;
+        progress?: string;
+    }>>;
+}>;

package/dist/apps/npx-resolve.d.ts

@@ -0,0 +1,11 @@
+export declare function inferNpmPackageNameFromSpec(spec: string): string | null;
+export declare function resolveNpxPackageRoot(params: {
+    spec: string;
+}): Promise<Readonly<{
+    kind: 'ok';
+    packageName: string;
+    packageRootAbs: string;
+}> | Readonly<{
+    kind: 'error';
+    errorText: string;
+}>>;

package/dist/apps/override-paths.d.ts

@@ -0,0 +1,25 @@
+type OverrideFileResolution = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'found';
+    filePathAbs: string;
+    source: 'rtws_override' | 'app_override';
+    ownerAppId: string | null;
+}>;
+/**
+ * Resolve an app asset override file path for a given app-relative file path.
+ *
+ * Priority order (read-time):
+ * 1) `<rtws>/.apps/override/<app-id>/<rel>`
+ * 2) `<integrator-app-root>/.apps/override/<app-id>/<rel>` (in provided order)
+ */
+export declare function resolveAppOverrideFileAbs(params: {
+    rtwsRootAbs: string;
+    appId: string;
+    appRelPath: string;
+    appOverrideOwners?: ReadonlyArray<Readonly<{
+        appId: string;
+        packageRootAbs: string;
+    }>>;
+}): Promise<OverrideFileResolution>;
+export {};

package/dist/apps/package-info.d.ts

@@ -0,0 +1,8 @@
+export type PackageInfo = Readonly<{
+    packageName: string | null;
+    packageVersion: string | null;
+    manifestRelPath: string;
+}>;
+export declare function readPackageInfo(params: {
+    packageRootAbs: string;
+}): Promise<PackageInfo>;

package/dist/apps/problems.d.ts

@@ -0,0 +1,4 @@
+import type { AppsResolutionIssue } from './enabled-apps';
+export declare function reconcileAppsResolutionIssuesToProblems(params: {
+    issues: ReadonlyArray<AppsResolutionIssue>;
+}): void;

package/dist/apps/resolution-file.d.ts

@@ -0,0 +1,60 @@
+import type { DomindsAppInstallJsonV1 } from './app-json';
+export type AppsResolutionSchemaVersion = 1;
+export type AppsResolutionSource = Readonly<{
+    kind: 'npx';
+    spec: string;
+}> | Readonly<{
+    kind: 'local';
+    pathAbs: string;
+}>;
+export type AppsResolutionEntry = Readonly<{
+    id: string;
+    enabled: boolean;
+    source: AppsResolutionSource;
+    assignedPort: number | null;
+    installJson: DomindsAppInstallJsonV1;
+}>;
+export type AppsResolutionFile = Readonly<{
+    schemaVersion: AppsResolutionSchemaVersion;
+    apps: ReadonlyArray<AppsResolutionEntry>;
+}>;
+export declare const APPS_RESOLUTION_REL_PATH: string;
+export declare function loadAppsResolutionFile(params: {
+    rtwsRootAbs: string;
+}): Promise<Readonly<{
+    kind: 'ok';
+    file: AppsResolutionFile;
+    filePathAbs: string;
+    exists: boolean;
+}> | Readonly<{
+    kind: 'error';
+    errorText: string;
+    filePathAbs: string;
+}>>;
+export declare function writeAppsResolutionFile(params: {
+    rtwsRootAbs: string;
+    file: AppsResolutionFile;
+}): Promise<void>;
+export declare function writeAppsResolutionFileIfChanged(params: {
+    rtwsRootAbs: string;
+    file: AppsResolutionFile;
+}): Promise<void>;
+export declare function findResolvedApp(file: AppsResolutionFile, appId: string): AppsResolutionEntry | null;
+export declare function upsertResolvedApp(params: {
+    existing: AppsResolutionFile;
+    next: AppsResolutionEntry;
+}): AppsResolutionFile;
+export declare function removeResolvedApp(params: {
+    existing: AppsResolutionFile;
+    appId: string;
+}): AppsResolutionFile;
+export declare function setResolvedAppEnabled(params: {
+    existing: AppsResolutionFile;
+    appId: string;
+    enabled: boolean;
+}): AppsResolutionFile;
+export declare function setResolvedAppAssignedPort(params: {
+    existing: AppsResolutionFile;
+    appId: string;
+    assignedPort: number | null;
+}): AppsResolutionFile;

package/dist/apps/rtws-seed.d.ts

@@ -0,0 +1,7 @@
+import type { DomindsAppManifest } from './manifest';
+export declare function applyRtwsSeed(params: {
+    rtwsRootAbs: string;
+    appId: string;
+    manifest: DomindsAppManifest;
+    overwrite: boolean;
+}): Promise<void>;

package/dist/apps/run-app-json.d.ts

@@ -0,0 +1,8 @@
+import { type DomindsAppInstallJsonV1 } from './app-json';
+export declare function runDomindsAppJsonViaNpx(params: {
+    spec: string;
+    cwdAbs: string;
+}): Promise<DomindsAppInstallJsonV1>;
+export declare function runDomindsAppJsonViaLocalPackage(params: {
+    packageRootAbs: string;
+}): Promise<DomindsAppInstallJsonV1>;

package/dist/apps/run-control.d.ts

@@ -0,0 +1,6 @@
+import type { DomindsAppRunControlContext, DomindsAppRunControlResult } from '../apps-host/app-host-contract';
+export declare function applyAppDialogRunControl(params: {
+    controlId: string;
+    payload: DomindsAppRunControlContext;
+}): Promise<DomindsAppRunControlResult>;
+export declare function applyRegisteredAppDialogRunControls(payload: DomindsAppRunControlContext): Promise<DomindsAppRunControlResult>;