@stream44.studio/t44 0.4.0-rc.24

package/package.json

@@ -0,0 +1,91 @@
+{
+    "name": "@stream44.studio/t44",
+    "version": "0.4.0-rc.24",
+    "license": "LGPL",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Stream44/t44.git"
+    },
+    "type": "module",
+    "bin": {
+        "t44": "./bin/t44"
+    },
+    "scripts": {
+        "test": "bun test"
+    },
+    "exports": {
+        "./workspace-rt": "./workspace-rt.ts",
+        "./standalone-rt": "./standalone-rt.ts",
+        "./caps/Home": "./caps/Home.ts",
+        "./caps/HomeRegistry": "./caps/HomeRegistry.ts",
+        "./caps/OpenApiSchema": "./caps/OpenApiSchema.ts",
+        "./caps/JsonSchemas": "./caps/JsonSchemas.ts",
+        "./caps/ProjectDeployment": "./caps/ProjectDeployment.ts",
+        "./caps/ProjectDevelopment": "./caps/ProjectDevelopment.ts",
+        "./caps/ProjectPublishing": "./caps/ProjectPublishing.ts",
+        "./caps/ProjectRack": "./caps/ProjectRack.ts",
+        "./caps/WorkspaceCli": "./caps/WorkspaceCli.ts",
+        "./caps/WorkspaceConfig": "./caps/WorkspaceConfig.ts",
+        "./caps/WorkspaceConnection": "./caps/WorkspaceConnection.ts",
+        "./caps/WorkspaceEntityConfig": "./caps/WorkspaceEntityConfig.ts",
+        "./caps/WorkspaceEntityFact": "./caps/WorkspaceEntityFact.ts",
+        "./caps/WorkspaceInfo": "./caps/WorkspaceInfo.ts",
+        "./caps/WorkspaceInit": "./caps/WorkspaceInit.ts",
+        "./caps/RootKey": "./caps/RootKey.ts",
+        "./caps/WorkspaceKey": "./caps/WorkspaceKey.ts",
+        "./caps/WorkspaceProjects": "./caps/WorkspaceProjects.ts",
+        "./caps/WorkspacePrompt": "./caps/WorkspacePrompt.ts",
+        "./caps/WorkspaceShell": "./caps/WorkspaceShell.ts",
+        "./caps/WorkspaceShellCli": "./caps/WorkspaceShellCli.ts",
+        "./caps/TaskWorkflow": "./caps/TaskWorkflow.ts",
+        "./caps/ProjectTest": "./caps/ProjectTest.ts",
+        "./caps/ProjectTestLib": "./caps/ProjectTestLib.ts",
+        "./caps/patterns/git-scm.com/ProjectPublishing": "./caps/patterns/git-scm.com/ProjectPublishing.ts",
+        "./caps/patterns/semver.org/ProjectPublishing": "./caps/patterns/semver.org/ProjectPublishing.ts",
+        "./structs/HomeRegistryConfig": "./structs/HomeRegistryConfig.ts",
+        "./structs/RootKeyConfig": "./structs/RootKeyConfig.ts",
+        "./structs/ProjectDeploymentConfig": "./structs/ProjectDeploymentConfig.ts",
+        "./structs/ProjectDeploymentFact": "./structs/ProjectDeploymentFact.ts",
+        "./structs/ProjectPublishingFact": "./structs/ProjectPublishingFact.ts",
+        "./structs/ProjectRackConfig": "./structs/ProjectRackConfig.ts",
+        "./structs/WorkspaceCliConfig": "./structs/WorkspaceCliConfig.ts",
+        "./structs/WorkspaceConfig": "./structs/WorkspaceConfig.ts",
+        "./structs/WorkspaceKeyConfig": "./structs/WorkspaceKeyConfig.ts",
+        "./structs/WorkspaceMappingsConfig": "./structs/WorkspaceMappingsConfig.ts",
+        "./structs/WorkspaceProjectsConfig": "./structs/WorkspaceProjectsConfig.ts",
+        "./structs/WorkspacePublishingConfig": "./structs/WorkspacePublishingConfig.ts",
+        "./structs/WorkspaceShellConfig": "./structs/WorkspaceShellConfig.ts",
+        "./structs/patterns/git-scm.com/ProjectPublishingFact": "./structs/patterns/git-scm.com/ProjectPublishingFact.ts"
+    },
+    "dependencies": {
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1",
+        "js-yaml": "^4.1.0",
+        "commander": "^14.0.0",
+        "chalk": "^5.6.2",
+        "dotenv": "^17.2.3",
+        "fast-glob": "^3.3.3",
+        "inquirer": "^12.4.0",
+        "axios": "^1.13.4",
+        "@ucanto/principal": "^9.0.3",
+        "@ucanto/server": "^11.0.3",
+        "json-schema-ref-resolver": "^3.0.0",
+        "@stream44.studio/encapsulate": "^0.4.0-rc.23",
+        "turbo": "^2.7.5"
+    },
+    "optionalDependencies": {
+        "@stream44.studio/t44-bunny.net": "^0.1.0-rc.4",
+        "@stream44.studio/t44-vercel.com": "^0.1.0-rc.4",
+        "@stream44.studio/t44-github.com": "^0.1.0-rc.4",
+        "@stream44.studio/t44-dynadot.com": "^0.1.0-rc.4",
+        "@stream44.studio/t44-npmjs.com": "^0.1.0-rc.4"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.4",
+        "@types/node": "^25.0.3",
+        "@types/js-yaml": "^4.0.9",
+        "bun-types": "^1.3.4"
+    },
+    "workspaces": [],
+    "private": false
+}

package/standalone-rt.test.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env bun test --timeout 30000
+
+import * as bunTest from 'bun:test'
+import { describe, it, expect } from 'bun:test'
+import { run } from './standalone-rt'
+
+// Top-level run() — shared across all tests (e.g. for workbenchDir)
+const { test: { workbenchDir } } = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+    const spine = await encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                test: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/ProjectTest',
+                    options: { '#': { bunTest, env: {} } }
+                },
+            }
+        }
+    }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44/standalone-rt.test' })
+    return { spine }
+}, async ({ spine, apis }: any) => {
+    return apis[spine.capsuleSourceLineRef]
+}, { importMeta: import.meta })
+
+describe('standalone-rt multiple run() calls', () => {
+
+    it('should support a second run() call with static options', async () => {
+        const result = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+            const spine = await encapsulate({
+                '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                    '#@stream44.studio/encapsulate/structs/Capsule': {},
+                    '#': {
+                        greeting: {
+                            type: CapsulePropertyTypes.Literal,
+                            value: 'hello-from-run-1',
+                        },
+                    }
+                }
+            }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44/standalone-rt.test.run1' })
+            return { spine }
+        }, async ({ spine, apis }: any) => {
+            return apis[spine.capsuleSourceLineRef].greeting
+        }, { importMeta: import.meta, runFromSnapshot: false })
+
+        expect(result).toBe('hello-from-run-1');
+    });
+
+    it('should support a third run() call with different options', async () => {
+        const result = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+            const spine = await encapsulate({
+                '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                    '#@stream44.studio/encapsulate/structs/Capsule': {},
+                    '#': {
+                        greeting: {
+                            type: CapsulePropertyTypes.Literal,
+                            value: 'hello-from-run-2',
+                        },
+                    }
+                }
+            }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44/standalone-rt.test.run2' })
+            return { spine }
+        }, async ({ spine, apis }: any) => {
+            return apis[spine.capsuleSourceLineRef].greeting
+        }, { importMeta: import.meta, runFromSnapshot: false })
+
+        expect(result).toBe('hello-from-run-2');
+    });
+
+    it('should support run() with closure variables in options', async () => {
+        const dynamicValue = `dynamic-${Date.now()}`;
+
+        const result = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+            const spine = await encapsulate({
+                '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                    '#@stream44.studio/encapsulate/structs/Capsule': {},
+                    '#': {
+                        value: {
+                            type: CapsulePropertyTypes.Literal,
+                            value: dynamicValue,
+                        },
+                    }
+                }
+            }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44/standalone-rt.test.closure' })
+            return { spine }
+        }, async ({ spine, apis }: any) => {
+            return apis[spine.capsuleSourceLineRef].value
+        }, { importMeta: import.meta, runFromSnapshot: false })
+
+        expect(result).toBe(dynamicValue);
+    });
+
+    it('should support run() with two capsules in the same spine', async () => {
+        const result = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+            const spineA = await encapsulate({
+                '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                    '#@stream44.studio/encapsulate/structs/Capsule': {},
+                    '#': {
+                        name: { type: CapsulePropertyTypes.Literal, value: 'capsule-a' },
+                    }
+                }
+            }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44/standalone-rt.test.multi-a' })
+
+            const spineB = await encapsulate({
+                '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                    '#@stream44.studio/encapsulate/structs/Capsule': {},
+                    '#': {
+                        name: { type: CapsulePropertyTypes.Literal, value: 'capsule-b' },
+                    }
+                }
+            }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44/standalone-rt.test.multi-b' })
+
+            return { spineA, spineB }
+        }, async ({ spineA, spineB, apis }: any) => {
+            return {
+                a: apis[spineA.capsuleSourceLineRef].name,
+                b: apis[spineB.capsuleSourceLineRef].name,
+            }
+        }, { importMeta: import.meta, runFromSnapshot: false })
+
+        expect(result.a).toBe('capsule-a');
+        expect(result.b).toBe('capsule-b');
+    });
+
+    it('should support run() with runFromSnapshot: true', async () => {
+        const result = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+            const spine = await encapsulate({
+                '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                    '#@stream44.studio/encapsulate/structs/Capsule': {},
+                    '#': {
+                        greeting: {
+                            type: CapsulePropertyTypes.Literal,
+                            value: 'hello-from-snapshot',
+                        },
+                    }
+                }
+            }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44/standalone-rt.test.snapshot' })
+            return { spine }
+        }, async ({ spine, apis }: any) => {
+            return apis[spine.capsuleSourceLineRef].greeting
+        }, { importMeta: import.meta, runFromSnapshot: true })
+
+        expect(result).toBe('hello-from-snapshot');
+    });
+
+    it('workbenchDir from top-level run() should still be available', () => {
+        expect(workbenchDir).toBeDefined();
+        expect(typeof workbenchDir).toBe('string');
+    });
+});

package/standalone-rt.ts

@@ -0,0 +1,140 @@
+#!/usr/bin/env bun
+/// <reference types="bun" />
+/// <reference types="node" />
+
+const startTime = Date.now()
+
+import { resolve, join } from 'path'
+import { access } from 'fs/promises'
+import chalk from 'chalk'
+import { CapsuleSpineFactory } from "@stream44.studio/encapsulate/spine-factories/CapsuleSpineFactory.v0"
+import { CapsuleSpineContract } from "@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0/Membrane.v0"
+import { TimingObserver } from "@stream44.studio/encapsulate/spine-factories/TimingObserver"
+
+async function findPackageRoot(startDir: string): Promise<string> {
+    let dir = resolve(startDir)
+    while (true) {
+        try {
+            await access(join(dir, 'package.json'))
+            return dir
+        } catch { }
+        const parent = resolve(dir, '..')
+        if (parent === dir) return resolve(startDir)
+        dir = parent
+    }
+}
+
+export async function run(encapsulateHandler: any, runHandler: any, options?: { importMeta?: { dir: string }, runFromSnapshot?: boolean }) {
+
+    const timing = process.argv.includes('--trace') ? TimingObserver({ startTime }) : undefined
+
+    timing?.recordMajor('INIT SPINE')
+
+    const eventsByKey = new Map<string, any>()
+
+    const spineFilesystemRoot = options?.importMeta?.dir
+        ? await findPackageRoot(options.importMeta.dir)
+        : process.cwd()
+
+    const { encapsulate, freeze, CapsulePropertyTypes, makeImportStack, hoistSnapshot, run: spineRun } = await CapsuleSpineFactory({
+        spineFilesystemRoot,
+        capsuleModuleProjectionRoot: options?.importMeta?.dir!,
+        enableCallerStackInference: true,
+        spineContracts: {
+            ['#' + CapsuleSpineContract['#']]: CapsuleSpineContract
+        },
+        timing,
+        onMembraneEvent: timing ? (event: any) => {
+            const instanceId = event.target?.spineContractCapsuleInstanceId
+            const eventIndex = event.eventIndex
+
+            // Store event by composite key (instance ID + event index)
+            const key = `${eventIndex}`
+            eventsByKey.set(key, event)
+
+            let capsuleRef = event.target?.capsuleSourceLineRef
+            let prop = event.target?.prop
+            let callerLocation = event.caller ? `${event.caller.filepath}:${event.caller.line}` : 'unknown'
+            const eventType = event.event
+
+            // For call-result events, look up the original call event to get all info
+            if (eventType === 'call-result') {
+                const callKey = `${event.callEventIndex}`
+                const callEvent = eventsByKey.get(callKey)
+                if (callEvent) {
+                    capsuleRef = callEvent.target?.capsuleSourceLineRef || capsuleRef
+                    prop = callEvent.target?.prop || prop
+                    if (callEvent.caller) {
+                        callerLocation = `${callEvent.caller.filepath}:${callEvent.caller.line}`
+                    }
+                }
+            }
+
+            console.error(
+                chalk.gray(`[${eventIndex}]`),
+                chalk.cyan(eventType.padEnd(12)),
+                chalk.yellow(capsuleRef),
+                chalk.magenta(`.${prop}`),
+                chalk.dim(`from ${callerLocation}`)
+            )
+        } : undefined
+    })
+
+    timing?.recordMajor('ENCAPSULATE')
+
+    const exportedApi = await encapsulateHandler({
+        encapsulate,
+        CapsulePropertyTypes,
+        makeImportStack
+    })
+
+    let run
+
+    if (options?.runFromSnapshot === false) {
+
+        run = spineRun
+
+        timing?.recordMajor('RUN (in-memory)')
+    } else {
+
+        timing?.recordMajor('FREEZE')
+
+        const snapshot = await freeze()
+
+        timing?.recordMajor('HOIST SNAPSHOT')
+
+        const spine = await hoistSnapshot({
+            snapshot
+        })
+
+        run = spine.run
+
+        timing?.recordMajor('RUN (snapshot)')
+    }
+
+    const result = await run({
+        overrides: {
+            ['@stream44.studio/t44/caps/ProjectTest']: {
+                '#': {
+                    testRootDir: options?.importMeta?.dir,
+                    verbose: !!process.env.VERBOSE,
+                }
+            },
+            ['@stream44.studio/t44-ipfs.tech/caps/IpfsWorkbench']: {
+                '#': {
+                    cacheDir: join(spineFilesystemRoot, '.~o/workspace.foundation', '@t44.sh~t44-ipfs.tech~caps~IpfsWorkbench', 'daemons')
+                }
+            }
+        }
+    }, async (opts) => {
+        return runHandler({
+            ...opts,
+            ...(exportedApi || {}),
+            spineFilesystemRoot
+        })
+    })
+
+    timing?.recordMajor('DONE')
+
+    return result
+}

package/structs/HomeRegistry.ts

@@ -0,0 +1,55 @@
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: any) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/t44/caps/ConfigSchemaStruct': {
+                as: 'schema',
+                options: {
+                    '#': {
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                did: {
+                                    type: 'string',
+                                    description: 'The DID (Decentralized Identifier) of the home registry.'
+                                },
+                                privateKey: {
+                                    type: 'string',
+                                    description: 'The private key associated with the home registry DID.'
+                                },
+                                createdAt: {
+                                    type: 'string',
+                                    format: 'date-time',
+                                    description: 'ISO 8601 timestamp of when the registry was created.'
+                                },
+                                rootDir: {
+                                    type: 'string',
+                                    description: 'Absolute path to the home registry root directory.'
+                                }
+                            },
+                            required: ['did', 'privateKey', 'createdAt', 'rootDir'],
+                            additionalProperties: false,
+                            description: 'Home registry identity containing the root DID and private key.'
+                        }
+                    }
+                }
+            },
+            '#': {
+                capsuleName: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: capsule['#']
+                },
+            }
+        }
+    }, {
+        extendsCapsule: '@stream44.studio/t44/caps/HomeRegistryFile',
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/structs/HomeRegistry'

package/structs/HomeRegistryConfig.ts

@@ -0,0 +1,60 @@
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: any) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/t44/caps/ConfigSchemaStruct': {
+                as: 'schema',
+                options: {
+                    '#': {
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                homeDir: {
+                                    type: 'string',
+                                    description: 'Absolute path to the home directory (parent of registry, .ssh, etc).'
+                                },
+                                rootDir: {
+                                    type: 'string',
+                                    description: 'Absolute path to the home registry root directory.'
+                                },
+                                identifier: {
+                                    type: 'string',
+                                    description: 'DID (Decentralized Identifier) of the home registry.'
+                                },
+                                createdAt: {
+                                    type: 'string',
+                                    format: 'date-time',
+                                    description: 'ISO 8601 timestamp of when the entity config was created.'
+                                },
+                                updatedAt: {
+                                    type: 'string',
+                                    format: 'date-time',
+                                    description: 'ISO 8601 timestamp of when the entity config was last updated.'
+                                }
+                            },
+                            required: ['createdAt', 'updatedAt'],
+                            additionalProperties: false,
+                            description: 'Home registry configuration with identity and location.'
+                        }
+                    }
+                }
+            },
+            '#': {
+                capsuleName: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: capsule['#']
+                },
+            }
+        }
+    }, {
+        extendsCapsule: '@stream44.studio/t44/caps/WorkspaceEntityConfig',
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/structs/HomeRegistryConfig'

package/structs/ProjectCatalogsConfig.ts

@@ -0,0 +1,53 @@
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: any) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/t44/caps/ConfigSchemaStruct': {
+                as: 'schema',
+                options: {
+                    '#': {
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                catalogs: {
+                                    type: 'object',
+                                    additionalProperties: true,
+                                    description: 'Map of catalog names to their configurations.'
+                                },
+                                createdAt: {
+                                    type: 'string',
+                                    format: 'date-time',
+                                    description: 'ISO 8601 timestamp of when the entity config was created.'
+                                },
+                                updatedAt: {
+                                    type: 'string',
+                                    format: 'date-time',
+                                    description: 'ISO 8601 timestamp of when the entity config was last updated.'
+                                }
+                            },
+                            required: ['createdAt', 'updatedAt'],
+                            additionalProperties: false,
+                            description: 'Project catalogs configuration.'
+                        }
+                    }
+                }
+            },
+            '#': {
+                capsuleName: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: capsule['#']
+                },
+            }
+        }
+    }, {
+        extendsCapsule: '@stream44.studio/t44/caps/WorkspaceEntityConfig',
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/structs/ProjectCatalogsConfig'

package/structs/ProjectDeploymentConfig.ts

@@ -0,0 +1,56 @@
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: any) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/t44/caps/ConfigSchemaStruct': {
+                as: 'schema',
+                options: {
+                    '#': {
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                deployments: {
+                                    type: 'object',
+                                    additionalProperties: {
+                                        type: 'object',
+                                        additionalProperties: true
+                                    },
+                                    description: 'Map of deployment names to their configurations.'
+                                },
+                                createdAt: {
+                                    type: 'string',
+                                    format: 'date-time',
+                                    description: 'ISO 8601 timestamp of when the entity config was created.'
+                                },
+                                updatedAt: {
+                                    type: 'string',
+                                    format: 'date-time',
+                                    description: 'ISO 8601 timestamp of when the entity config was last updated.'
+                                }
+                            },
+                            required: ['createdAt', 'updatedAt'],
+                            additionalProperties: false,
+                            description: 'Project deployment configurations for deployment providers.'
+                        }
+                    }
+                }
+            },
+            '#': {
+                capsuleName: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: capsule['#']
+                },
+            }
+        }
+    }, {
+        extendsCapsule: '@stream44.studio/t44/caps/WorkspaceEntityConfig',
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/structs/ProjectDeploymentConfig'