@stream44.studio/encapsulate 0.4.0-rc.11 → 0.4.0-rc.13

package/src/spine-contracts/CapsuleSpineContract.v0/Static.v0.ts

@@ -17,10 +17,11 @@ export class ContractCapsuleInstanceFactory {
     protected extendedCapsuleInstance?: any
     protected ownSelf?: any
     protected runtimeSpineContracts?: Record<string, any>
+    protected capsuleInstance?: any
     public structInitFunctions: Array<() => any> = []
     public mappedCapsuleInstances: Array<any> = []
 
-    constructor({ spineContractUri, capsule, self, ownSelf, encapsulatedApi, resolve, importCapsule, spineFilesystemRoot, freezeCapsule, instanceRegistry, extendedCapsuleInstance, runtimeSpineContracts }: { spineContractUri: string, capsule: any, self: any, ownSelf?: any, encapsulatedApi: Record<string, any>, resolve?: (uri: string, parentFilepath: string) => Promise<string>, importCapsule?: (filepath: string) => Promise<any>, spineFilesystemRoot?: string, freezeCapsule?: (capsule: any) => Promise<any>, instanceRegistry?: CapsuleInstanceRegistry, extendedCapsuleInstance?: any, runtimeSpineContracts?: Record<string, any> }) {
+    constructor({ spineContractUri, capsule, self, ownSelf, encapsulatedApi, resolve, importCapsule, spineFilesystemRoot, freezeCapsule, instanceRegistry, extendedCapsuleInstance, runtimeSpineContracts, capsuleInstance }: { spineContractUri: string, capsule: any, self: any, ownSelf?: any, encapsulatedApi: Record<string, any>, resolve?: (uri: string, parentFilepath: string) => Promise<string>, importCapsule?: (filepath: string) => Promise<any>, spineFilesystemRoot?: string, freezeCapsule?: (capsule: any) => Promise<any>, instanceRegistry?: CapsuleInstanceRegistry, extendedCapsuleInstance?: any, runtimeSpineContracts?: Record<string, any>, capsuleInstance?: any }) {
         this.spineContractUri = spineContractUri
         this.capsule = capsule
         this.self = self
@@ -33,6 +34,7 @@ export class ContractCapsuleInstanceFactory {
         this.instanceRegistry = instanceRegistry
         this.extendedCapsuleInstance = extendedCapsuleInstance
         this.runtimeSpineContracts = runtimeSpineContracts
+        this.capsuleInstance = capsuleInstance
     }
 
     async mapProperty({ overrides, options, property }: { overrides: any, options: any, property: any }) {
@@ -40,7 +42,8 @@ export class ContractCapsuleInstanceFactory {
             await this.mapMappingProperty({ overrides, options, property })
         } else if (
             property.definition.type === CapsulePropertyTypes.String ||
-            property.definition.type === CapsulePropertyTypes.Literal
+            property.definition.type === CapsulePropertyTypes.Literal ||
+            property.definition.type === CapsulePropertyTypes.Constant
         ) {
             this.mapLiteralProperty({ property })
         } else if (property.definition.type === CapsulePropertyTypes.Function) {
@@ -226,7 +229,8 @@ export class ContractCapsuleInstanceFactory {
         const mappedInstance = await mappedCapsule.makeInstance({
             overrides: mappedOverrides,
             options: mappingOptions,
-            runtimeSpineContracts: this.runtimeSpineContracts
+            runtimeSpineContracts: this.runtimeSpineContracts,
+            rootCapsule: this.capsuleInstance?.rootCapsule
         })
 
         // Register the instance (replaces null pre-registration marker)
@@ -369,7 +373,7 @@ export function CapsuleSpineContract({ freezeCapsule, resolve, importCapsule, sp
     return {
         '#': CapsuleSpineContract['#'],
         instanceRegistry,
-        makeContractCapsuleInstance: ({ spineContractUri, capsule, self, ownSelf, encapsulatedApi, extendedCapsuleInstance, runtimeSpineContracts }: { spineContractUri: string, capsule: any, self: any, ownSelf?: any, encapsulatedApi: Record<string, any>, extendedCapsuleInstance?: any, runtimeSpineContracts?: Record<string, any> }) => {
+        makeContractCapsuleInstance: ({ spineContractUri, capsule, self, ownSelf, encapsulatedApi, extendedCapsuleInstance, runtimeSpineContracts, capsuleInstance }: { spineContractUri: string, capsule: any, self: any, ownSelf?: any, encapsulatedApi: Record<string, any>, extendedCapsuleInstance?: any, runtimeSpineContracts?: Record<string, any>, capsuleInstance?: any }) => {
             return new ContractCapsuleInstanceFactory({
                 spineContractUri,
                 capsule,
@@ -382,7 +386,8 @@ export function CapsuleSpineContract({ freezeCapsule, resolve, importCapsule, sp
                 freezeCapsule,
                 instanceRegistry,
                 extendedCapsuleInstance,
-                runtimeSpineContracts
+                runtimeSpineContracts,
+                capsuleInstance
             })
         },
         hydrate: ({ capsuleSnapshot }: { capsuleSnapshot: any }): any => {

package/src/spine-factories/CapsuleSpineFactory.v0.ts

@@ -212,9 +212,42 @@ async function resolve(uri: string, fromPath: string, spineRoot?: string): Promi
 
     // Non-scoped bare specifier — try node_modules resolution from fromPath
     if (!uri.startsWith('.') && !uri.startsWith('/')) {
-        // Walk up from fromPath looking for node_modules
+        // Parse package name and subpath (e.g., "t44/caps/WorkspaceCli" -> pkg="t44", subpath="caps/WorkspaceCli")
+        const slashIdx = uri.indexOf('/')
+        const pkg = slashIdx === -1 ? uri : uri.slice(0, slashIdx)
+        const subpath = slashIdx === -1 ? undefined : uri.slice(slashIdx + 1)
+
+        // Walk up from fromPath looking for self-package or node_modules
         let dir = dirname(fromPath)
         while (true) {
+            // Check if this directory's package.json matches the requested package (self-package resolution)
+            try {
+                const pjPath = join(dir, 'package.json')
+                const pj = JSON.parse(await readFile(pjPath, 'utf-8'))
+                if (pj.name === pkg) {
+                    if (subpath) {
+                        if (pj.exports) {
+                            const exportKey = './' + subpath
+                            const exportValue = pj.exports[exportKey]
+                            if (typeof exportValue === 'string') {
+                                return pathResolve(dir, exportValue)
+                            }
+                        }
+                        const fsPath = join(dir, subpath + '.ts')
+                        try { await stat(fsPath); return fsPath } catch { }
+                        try { await stat(join(dir, subpath)); return join(dir, subpath) } catch { }
+                    } else if (pj.exports?.['.']) {
+                        const mainExport = pj.exports['.']
+                        if (typeof mainExport === 'string') {
+                            return pathResolve(dir, mainExport)
+                        }
+                    } else if (pj.main) {
+                        return pathResolve(dir, pj.main)
+                    }
+                }
+            } catch { }
+
+            // Check node_modules
             const candidate = join(dir, 'node_modules', uri)
             try {
                 const s = await stat(candidate)
@@ -499,7 +532,7 @@ export async function CapsuleSpineFactory({
 
     timing?.recordMajor('CAPSULE SPINE FACTORY: READY')
 
-    const loadCapsule = async ({ capsuleSnapshot }: { capsuleSourceLineRef: string, capsuleSnapshot: any }) => {
+    const loadCapsule = async ({ capsuleSnapshot, cacheBustVersion }: { capsuleSourceLineRef: string, capsuleSnapshot: any, cacheBustVersion?: number }) => {
 
         if (!capsuleModuleProjectionRoot) {
             throw new Error('capsuleModuleProjectionRoot must be provided to enable dynamic loading of capsules')
@@ -509,6 +542,11 @@ export async function CapsuleSpineFactory({
 
         if (!filepath) throw new Error(`Cannot load capsule. No 'filepath' found at 'spineContracts["#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0"]["#@stream44.studio/encapsulate/structs/Capsule"].projectedCapsuleFilepath'!`)
 
+        // Check cache bust version - if it doesn't match, return null to trigger regeneration
+        if (cacheBustVersion !== undefined && capsuleSnapshot.cst?.cacheBustVersion !== cacheBustVersion) {
+            return null
+        }
+
         const { capsule } = await import(join(capsuleModuleProjectionRoot, filepath))
 
         return capsule
@@ -529,6 +567,7 @@ export async function CapsuleSpineFactory({
 
             const result = await SpineRuntime({
                 snapshot,
+                spineFilesystemRoot,
                 spineContracts: spineContractInstances.runtime,
                 loadCapsule
             })

package/src/static-analyzer.v0.ts

@@ -235,10 +235,18 @@ export function StaticAnalyzer({
                         ])
 
                         if (cstsContent && crtsContent) {
-                            timing?.record(`StaticAnalyzer: Cache HIT for ${encapsulateOptions.moduleFilepath}`)
-                            return {
-                                csts: JSON.parse(cstsContent),
-                                crts: JSON.parse(crtsContent)
+                            const cachedCsts = JSON.parse(cstsContent)
+
+                            // Check cache bust version - if mismatch, regenerate
+                            const cachedVersion = cachedCsts?.[capsuleSourceLineRef]?.cacheBustVersion
+                            if (encapsulateOptions.cacheBustVersion !== undefined && cachedVersion !== encapsulateOptions.cacheBustVersion) {
+                                timing?.record(timing?.chalk?.red?.(`StaticAnalyzer: Cache BUST (version mismatch: ${cachedVersion} !== ${encapsulateOptions.cacheBustVersion}) for ${encapsulateOptions.moduleFilepath}`))
+                            } else {
+                                timing?.record(`StaticAnalyzer: Cache HIT for ${encapsulateOptions.moduleFilepath}`)
+                                return {
+                                    csts: cachedCsts,
+                                    crts: JSON.parse(crtsContent)
+                                }
                             }
                         }
                     }
@@ -340,6 +348,7 @@ export function StaticAnalyzer({
                     )
 
                     const cst: any = {
+                        cacheBustVersion: encapsulateOptions.cacheBustVersion || 1,
                         capsuleSourceLineRef,
                         capsuleSourceNameRef,
                         capsuleSourceNameRefHash,