@stream44.studio/encapsulate 0.4.0-rc.27 → 0.4.0-rc.29

package/README.md

@@ -3,7 +3,7 @@
     <td><a href="https://Stream44.Studio"><img src=".o/stream44.studio/assets/Icon-v1.svg" width="42" height="42"></a></td>
     <td><strong><a href="https://Stream44.Studio">Stream44 Studio</a></strong><br/>Open Development Project</td>
     <td>Preview release for community feedback.<br/>Get in touch on <a href="https://discord.gg/9eBcQXEJAN">discord</a>.</td>
-    <td>Hand Designed<br/><b>AI Coded Alpha</a></td>
+    <td>Designed by Hand<br/><b>AI assisted Code</a></td>
   </tr>
 </table>
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stream44.studio/encapsulate",
-    "version": "0.4.0-rc.27",
+    "version": "0.4.0-rc.29",
     "license": "MIT",
     "repository": {
         "type": "git",

package/src/capsule-projectors/CapsuleModuleProjector.v0.ts

@@ -174,7 +174,7 @@ export function CapsuleModuleProjector({
                             for (const [key, potentialCapsule] of Object.entries(capsules)) {
                                 if (potentialCapsule === capsule) continue
 
-                                const mappedModulePath = potentialCapsule.cst?.source?.moduleFilepath
+                                const mappedModulePath = potentialCapsule.cst?.source?.moduleUri
 
                                 if (mappedModulePath && (
                                     mappedModulePath === mappingValue ||
@@ -224,7 +224,7 @@ export function CapsuleModuleProjector({
                                         for (const [key, potentialCapsule] of Object.entries(capsules)) {
                                             if (potentialCapsule === capsule) continue
 
-                                            const mappedModulePath = potentialCapsule.cst?.source?.moduleFilepath
+                                            const mappedModulePath = potentialCapsule.cst?.source?.moduleUri
 
                                             if (mappedModulePath && (
                                                 mappedModulePath === mappingValue ||
@@ -515,7 +515,7 @@ export function CapsuleModuleProjector({
             projectingCapsules.add(capsuleId)
         }
 
-        timing?.record(`Projector: Start projection for ${capsule.cst.source.moduleFilepath}`)
+        timing?.record(`Projector: Start projection for ${capsule.cst.source.moduleUri || capsule.cst.source.moduleFilepath}`)
 
         // Only project capsules that have the Capsule struct property
         const spineContract = capsule.cst.spineContracts[spineContractUri]
@@ -571,10 +571,10 @@ export function CapsuleModuleProjector({
                         if (allProjectedFilesExist) {
                             // Restore snapshotValues from cache
                             Object.assign(snapshotValues, merge(snapshotValues, cachedData.snapshotData))
-                            timing?.record(`Projector: Cache HIT for ${capsule.cst.source.moduleFilepath}`)
+                            timing?.record(`Projector: Cache HIT for ${capsule.cst.source.moduleUri || capsule.cst.source.moduleFilepath}`)
                             return true
                         } else {
-                            timing?.record(timing?.chalk?.yellow?.(`Projector: Cache INVALID (projected files missing) for ${capsule.cst.source.moduleFilepath}`))
+                            timing?.record(timing?.chalk?.yellow?.(`Projector: Cache INVALID (projected files missing) for ${capsule.cst.source.moduleUri || capsule.cst.source.moduleFilepath}`))
                         }
                     }
                 }
@@ -588,7 +588,7 @@ export function CapsuleModuleProjector({
 
                         // Check if this capsule has the Capsule struct (meaning it should be projected)
                         if (potentialMappedCapsule.cst?.spineContracts?.[spineContractUri]?.propertyContracts?.['#@stream44.studio/encapsulate/structs/Capsule']) {
-                            // Check if this capsule's moduleFilepath is referenced in any mapping property
+                            // Check if this capsule's moduleUri is referenced in any mapping property
                             const mappedModulePath = potentialMappedCapsule.cst.source.moduleFilepath
 
                             for (const [propContractKey, propContract] of Object.entries(spineContract.propertyContracts)) {
@@ -612,7 +612,7 @@ export function CapsuleModuleProjector({
                         }
                     }
                 }
-                timing?.record(timing?.chalk?.red?.(`Projector: Cache MISS for ${capsule.cst.source.moduleFilepath}`))
+                timing?.record(timing?.chalk?.red?.(`Projector: Cache MISS for ${capsule.cst.source.moduleUri || capsule.cst.source.moduleFilepath}`))
             } catch (error) {
                 // Cache miss or error, proceed with projection
             }
@@ -633,13 +633,13 @@ export function CapsuleModuleProjector({
 
             const cstJson = JSON.stringify(targetCapsule.cst, null, 4)
             const crtJson = JSON.stringify(targetCapsule.crt || {}, null, 4)
-            const moduleFilepath = targetCapsule.cst.source.moduleFilepath
+            const moduleUri = targetCapsule.cst.source.moduleUri
             const importStackLine = targetCapsule.cst.source.importStackLine
 
-            // Replace importMeta: import.meta with moduleFilepath: '...'
+            // Replace importMeta: import.meta with moduleFilepath: '...' (using npm URI)
             expression = expression.replace(
                 /importMeta:\s*import\.meta/g,
-                `moduleFilepath: '${moduleFilepath}'`
+                `moduleFilepath: '${moduleUri}'`
             )
 
             // Replace importStack: makeImportStack() with importStackLine: ..., crt: {...}, cst: {...}
@@ -1662,7 +1662,7 @@ ${mappedDefaultExport}
                 await projectionCacheStore.writeFile(cacheFilename, JSON.stringify(cacheData, null, 2))
             } catch (error) {
                 // Cache write error, continue without failing
-                console.warn(`Warning: Failed to write projection cache for ${capsule.cst.source.moduleFilepath}:`, error)
+                console.warn(`Warning: Failed to write projection cache for ${capsule.cst.source.moduleUri || capsule.cst.source.moduleFilepath}:`, error)
             }
         }
 
@@ -1749,7 +1749,7 @@ capsule['#'] = ${JSON.stringify(capsuleName)}
                         await projectionStore.writeFile(projectedPath, capsuleFileContent)
                     }
                 } catch (error) {
-                    console.warn(`Warning: Failed to write projection cache for capsule ${registryCapsule.cst.source.moduleFilepath}:`, error)
+                    console.warn(`Warning: Failed to write projection cache for capsule ${registryCapsule.cst.source.moduleUri || registryCapsule.cst.source.moduleFilepath}:`, error)
                 }
             }
         }

package/src/encapsulate.ts

@@ -1,7 +1,7 @@
 
 // CACHE_BUST_VERSION: Increment this whenever CST cache must be invalidated due to structural changes
 // This ensures projected capsules are regenerated when the CST format changes
-const CACHE_BUST_VERSION = 21
+const CACHE_BUST_VERSION = 22
 
 type TSpineOptions = {
     spineFilesystemRoot?: string,
@@ -505,21 +505,30 @@ async function encapsulate(definition: TCapsuleDefinition, options: TCapsuleOpti
 
     if (typeof importStackLine !== 'number') throw new Error(`Could not determine importStackLine from options`)
 
-    const capsuleSourceLineRef = `${moduleFilepath}:${importStackLine}`
+    // Temporary filesystem-based ref used only for passing to static analyzer
+    const fsBasedRef = `${moduleFilepath}:${importStackLine}`
 
     spine.spineOptions.timing?.record(`Encapsulate: Start for ${moduleFilepath}`)
 
-    const { csts, crts } = await spine.spineOptions.staticAnalyzer?.parseModule({
+    const parseResult = await spine.spineOptions.staticAnalyzer?.parseModule({
         spineOptions: spine.spineOptions,
         encapsulateOptions: {
             moduleFilepath,
             importStackLine,
-            capsuleSourceLineRef,
+            capsuleSourceLineRef: fsBasedRef,
             capsuleName: options.capsuleName,
             ambientReferences: options.ambientReferences,
             cacheBustVersion: CACHE_BUST_VERSION
         }
-    }) || {
+    })
+
+    // Use moduleUri from static analyzer for npm URI-based capsuleSourceLineRef
+    const moduleUri = parseResult?.moduleUri
+    const capsuleSourceLineRef = moduleUri
+        ? `${moduleUri}:${importStackLine}`
+        : fsBasedRef
+
+    const { csts, crts } = parseResult || {
         csts: options.cst ? { [capsuleSourceLineRef]: options.cst } : undefined,
         crts: options.crt ? { [capsuleSourceLineRef]: options.crt } : undefined
     }

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

@@ -140,11 +140,16 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
 
         // delegateOptions is set by encapsulate.ts for property contract delegates
         // options can be a function or an object for regular mappings
-        // Always pass { self, constants } - self is populated when depends is specified, empty otherwise
+        // Always pass { self, constants } - self contains full parent self when depends is specified,
+        // otherwise just the Capsule metadata struct (moduleFilepath, capsuleName, etc.)
         const optionsFn = property.definition.options
+        const capsuleStructKey = '#@stream44.studio/encapsulate/structs/Capsule'
+        const minimalSelf = this.self[capsuleStructKey]
+            ? { [capsuleStructKey]: this.self[capsuleStructKey] }
+            : {}
         const mappingOptions = property.definition.delegateOptions
             || (typeof optionsFn === 'function'
-                ? await optionsFn({ self: property.definition.depends ? this.self : {}, constants })
+                ? await optionsFn({ self: property.definition.depends ? this.self : minimalSelf, constants })
                 : optionsFn)
 
         // Check for existing instance in registry - reuse if available (regardless of options)
@@ -417,6 +422,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                 const event: any = {
                     event: 'get',
                     eventIndex: this.incrementEventIndex(),
+                    membrane: 'external',
                     target: {
                         capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
                         spineContractCapsuleInstanceId: this.id,
@@ -445,6 +451,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                 const event: any = {
                     event: 'set',
                     eventIndex: this.incrementEventIndex(),
+                    membrane: 'external',
                     target: {
                         capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
                         spineContractCapsuleInstanceId: this.id,
@@ -511,6 +518,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                         const callEvent: any = {
                             event: 'call',
                             eventIndex: this.incrementEventIndex(),
+                            membrane: 'external',
                             target: {
                                 capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
                                 spineContractCapsuleInstanceId: this.id,
@@ -536,6 +544,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                         const resultEvent: any = {
                             event: 'call-result',
                             eventIndex: this.incrementEventIndex(),
+                            membrane: 'external',
                             callEventIndex: callEvent.eventIndex,
                             target: {
                                 spineContractCapsuleInstanceId: this.id,
@@ -552,6 +561,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                     const callEvent: any = {
                         event: 'call',
                         eventIndex: this.incrementEventIndex(),
+                        membrane: 'external',
                         target: {
                             capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
                             spineContractCapsuleInstanceId: this.id,
@@ -588,6 +598,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                     const resultEvent: any = {
                         event: 'call-result',
                         eventIndex: this.incrementEventIndex(),
+                        membrane: 'external',
                         callEventIndex: callEvent.eventIndex,
                         target: {
                             spineContractCapsuleInstanceId: this.id,
@@ -637,6 +648,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                     const event: any = {
                         event: 'get',
                         eventIndex: this.incrementEventIndex(),
+                        membrane: 'external',
                         target: {
                             capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
                             spineContractCapsuleInstanceId: this.id,
@@ -673,6 +685,7 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
                 const event: any = {
                     event: 'get',
                     eventIndex: this.incrementEventIndex(),
+                    membrane: 'external',
                     target: {
                         capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
                         spineContractCapsuleInstanceId: this.id,
@@ -718,6 +731,134 @@ class MembraneContractCapsuleInstanceFactory extends ContractCapsuleInstanceFact
         }
     }
 
+    protected override createSelfProxy() {
+        const extendedApi = this.extendedCapsuleInstance?.api
+        const ownSelf = this.ownSelf
+        const factory = this
+        return new Proxy(this.self, {
+            get: (target: any, prop: string | symbol) => {
+                if (typeof prop === 'symbol') return target[prop]
+
+                // 'self' property returns ownSelf (only this capsule's own properties)
+                if (prop === 'self' && ownSelf) {
+                    return ownSelf
+                }
+
+                // Determine the value source and get the value
+                let value: any
+                let source: 'self' | 'encapsulatedApi' | 'childApi' | 'extendedApi' | undefined
+
+                if (prop in target) {
+                    value = target[prop]
+                    source = 'self'
+                } else if (prop in factory.encapsulatedApi) {
+                    value = factory.encapsulatedApi[prop]
+                    source = 'encapsulatedApi'
+                } else if (factory.childEncapsulatedApis) {
+                    for (const childApi of factory.childEncapsulatedApis) {
+                        if (prop in childApi) {
+                            value = childApi[prop]
+                            source = 'childApi'
+                            break
+                        }
+                    }
+                }
+
+                if (source === undefined && extendedApi && prop in extendedApi) {
+                    value = extendedApi[prop]
+                    source = 'extendedApi'
+                }
+
+                // Only emit internal events if we're inside a function/getter execution (caller context is set)
+                // and the property is not a function (we don't want to emit get events for function references)
+                if (source && typeof value !== 'function' && this.getCurrentCallerContext()) {
+                    const event: any = {
+                        event: 'get',
+                        eventIndex: this.incrementEventIndex(),
+                        membrane: 'internal',
+                        target: {
+                            capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
+                            spineContractCapsuleInstanceId: this.id,
+                            prop: prop as string,
+                        },
+                        value
+                    }
+
+                    if (this.capsuleSourceNameRef) {
+                        event.target.capsuleSourceNameRef = this.capsuleSourceNameRef
+                    }
+                    if (this.capsuleSourceNameRefHash) {
+                        event.target.capsuleSourceNameRefHash = this.capsuleSourceNameRefHash
+                    }
+
+                    this.addCallerContextToEvent(event)
+                    this.onMembraneEvent?.(event)
+                }
+
+                return value
+            },
+            ownKeys: (target: any) => {
+                const keys = new Set<string>(Object.keys(target))
+                for (const k of Object.keys(factory.encapsulatedApi)) keys.add(k)
+                if (factory.childEncapsulatedApis) {
+                    for (const childApi of factory.childEncapsulatedApis) {
+                        for (const k of Object.keys(childApi)) keys.add(k)
+                    }
+                }
+                if (extendedApi) {
+                    for (const k of Object.keys(extendedApi)) keys.add(k)
+                }
+                return [...keys]
+            },
+            set: (target: any, prop: string | symbol, value: any) => {
+                if (typeof prop === 'symbol') {
+                    target[prop] = value
+                    return true
+                }
+
+                // Emit internal set event if we're inside a function/getter execution
+                if (this.getCurrentCallerContext()) {
+                    const event: any = {
+                        event: 'set',
+                        eventIndex: this.incrementEventIndex(),
+                        membrane: 'internal',
+                        target: {
+                            capsuleSourceLineRef: this.encapsulateOptions.capsuleSourceLineRef,
+                            spineContractCapsuleInstanceId: this.id,
+                            prop: prop as string,
+                        },
+                        value
+                    }
+
+                    if (this.capsuleSourceNameRef) {
+                        event.target.capsuleSourceNameRef = this.capsuleSourceNameRef
+                    }
+                    if (this.capsuleSourceNameRefHash) {
+                        event.target.capsuleSourceNameRefHash = this.capsuleSourceNameRefHash
+                    }
+
+                    this.addCallerContextToEvent(event)
+                    this.onMembraneEvent?.(event)
+                }
+
+                target[prop] = value
+                return true
+            },
+            getOwnPropertyDescriptor: (target: any, prop: string | symbol) => {
+                if (typeof prop === 'symbol') return Object.getOwnPropertyDescriptor(target, prop)
+                if (prop in target) return Object.getOwnPropertyDescriptor(target, prop)
+                if (prop in factory.encapsulatedApi) return { configurable: true, enumerable: true, writable: true, value: factory.encapsulatedApi[prop as string] }
+                if (factory.childEncapsulatedApis) {
+                    for (const childApi of factory.childEncapsulatedApis) {
+                        if (prop in childApi) return { configurable: true, enumerable: true, writable: true, value: childApi[prop as string] }
+                    }
+                }
+                if (extendedApi && prop in extendedApi) return { configurable: true, enumerable: true, writable: true, value: extendedApi[prop as string] }
+                return undefined
+            }
+        })
+    }
+
     private addCallerContextToEvent(event: any): void {
         const callerCtx = this.getCurrentCallerContext()
         if (callerCtx) {
@@ -782,6 +923,20 @@ export function CapsuleSpineContract({
     let currentCallerContext: CallerContext | undefined = undefined
     const instanceRegistry: CapsuleInstanceRegistry = new Map()
 
+    // Re-entrancy guard: suppress event emission while inside an onMembraneEvent callback.
+    // This prevents consumers (e.g. JSON.stringify on event.value) from triggering proxy getters
+    // that would cause spurious recursive membrane events with wrong caller context and ordering.
+    let isEmittingEvent = false
+    const guardedOnMembraneEvent = onMembraneEvent ? (event: any) => {
+        if (isEmittingEvent) return
+        isEmittingEvent = true
+        try {
+            onMembraneEvent(event)
+        } finally {
+            isEmittingEvent = false
+        }
+    } : undefined
+
     return {
         '#': CapsuleSpineContract['#'],
         instanceRegistry,
@@ -796,7 +951,7 @@ export function CapsuleSpineContract({
                 freezeCapsule,
                 resolve,
                 importCapsule,
-                onMembraneEvent,
+                onMembraneEvent: guardedOnMembraneEvent,
                 enableCallerStackInference,
                 encapsulateOptions,
                 getEventIndex: () => eventIndex,

package/src/spine-contracts/CapsuleSpineContract.v0/README.md

@@ -308,8 +308,8 @@ prop: {
 - **`options`** — forwarded to the mapped capsule. Keys starting with `'#'` target the mapped capsule's own property contracts. Keys without `'#'` are matched against capsule names deeper in the mapping tree (nested capsule-name-targeted options).
 - **`options({ self, constants })`** — when `options` is a function, it receives `{ self, constants }`.
   - `constants` — all `Literal`/`String` values from the mapped capsule's definition.
-  - `self` — the parent capsule's `self` object with resolved sibling mappings. Only populated when `depends` is specified (empty `{}` otherwise).
-- **`depends`** — array of sibling property names that must be resolved before this mapping's `options` function runs. Enables `options({ self })` to access already-resolved siblings (e.g. `self.$auth.realm`) and the Capsule metadata struct (e.g. `self['#@stream44.studio/encapsulate/structs/Capsule'].capsuleName`). Can be declared explicitly or auto-injected by the static analyzer when it detects `self.<name>` references in the options function body.
+  - `self` — always contains the Capsule metadata struct (`self['#@stream44.studio/encapsulate/structs/Capsule']` with `moduleFilepath`, `capsuleName`, etc.). When `depends` is specified, `self` also contains the full parent capsule's resolved sibling mappings.
+- **`depends`** — array of sibling property names that must be resolved before this mapping's `options` function runs. Enables `options({ self })` to access already-resolved siblings (e.g. `self.$auth.realm`). Can be declared explicitly or auto-injected by the static analyzer when it detects `self.<name>` references in the options function body.
 - **Instance reuse** — named capsules are registered in an instance registry. If a capsule with the same name is mapped multiple times without options, the existing instance is reused via a deferred proxy.
 
 Mapped capsules are accessible via `this.<prop>` (unwrapped API) and `api.<prop>` (raw instance with `.api`).

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

@@ -129,8 +129,9 @@ export class ContractCapsuleInstanceFactory {
             if (!this.spineFilesystemRoot) throw new Error(`'spineFilesystemRoot' not set!`)
             if (!this.importCapsule) throw new Error(`'importCapsule' not set!`)
 
-            // Use encapsulateOptions.moduleFilepath (always available) instead of cst.source.moduleFilepath
-            const moduleFilepath = this.capsule.encapsulateOptions?.moduleFilepath || this.capsule.cst?.source?.moduleFilepath
+            // Use cst.source.moduleFilepath (always filesystem-relative) for path resolution.
+            // encapsulateOptions.moduleFilepath may be an npm URI when loaded from projected files.
+            const moduleFilepath = this.capsule.cst?.source?.moduleFilepath || this.capsule.encapsulateOptions?.moduleFilepath
             if (!moduleFilepath) throw new Error(`'moduleFilepath' not available on capsule!`)
 
             const parentPath = join(this.spineFilesystemRoot, moduleFilepath)
@@ -197,11 +198,16 @@ export class ContractCapsuleInstanceFactory {
 
         // delegateOptions is set by encapsulate.ts for property contract delegates
         // options can be a function or an object for regular mappings
-        // Always pass { self, constants } - self is populated when depends is specified, empty otherwise
+        // Always pass { self, constants } - self contains full parent self when depends is specified,
+        // otherwise just the Capsule metadata struct (moduleFilepath, capsuleName, etc.)
         const optionsFn = property.definition.options
+        const capsuleStructKey = '#@stream44.studio/encapsulate/structs/Capsule'
+        const minimalSelf = this.self[capsuleStructKey]
+            ? { [capsuleStructKey]: this.self[capsuleStructKey] }
+            : {}
         const mappingOptions = property.definition.delegateOptions
             || (typeof optionsFn === 'function'
-                ? await optionsFn({ self: property.definition.depends ? this.self : {}, constants })
+                ? await optionsFn({ self: property.definition.depends ? this.self : minimalSelf, constants })
                 : optionsFn)
 
         // Check for existing instance in registry - reuse if available when no options

package/src/static-analyzer.v0.ts

@@ -244,25 +244,13 @@ export function StaticAnalyzer({
 
             const moduleFilepath = join(spineOptions.spineFilesystemRoot, encapsulateOptions.moduleFilepath)
 
-            // Determine the cache file path based on whether the module is external or internal
-            let cacheFilePath: string
-            const isExternal = encapsulateOptions.moduleFilepath.startsWith('../')
-            const hasNodeModules = encapsulateOptions.moduleFilepath.includes('node_modules/')
-
-            if (isExternal || hasNodeModules) {
-                // External module or node_modules path - construct npm URI
-                const npmUri = await constructNpmUri(moduleFilepath, spineOptions.spineFilesystemRoot)
-                if (npmUri) {
-                    // Prefix with o/npmjs.com/node_modules/ for external modules
-                    cacheFilePath = `o/npmjs.com/node_modules/${npmUri}`
-                } else {
-                    // Fallback to normalized path if npm URI construction fails
-                    cacheFilePath = normalize(encapsulateOptions.moduleFilepath).replace(/^\.\.\//, '').replace(/\.\.\//g, '')
-                }
-            } else {
-                // Internal module - use relative path as-is
-                cacheFilePath = encapsulateOptions.moduleFilepath
-            }
+            // Construct npm URI for the module upfront — used for cache paths and CST keys
+            const rawModuleUri: string = await constructNpmUri(moduleFilepath, spineOptions.spineFilesystemRoot) || encapsulateOptions.moduleFilepath
+            // Strip file extension from URI
+            const moduleUriWithoutExt = rawModuleUri.replace(/\.(ts|tsx|js|jsx)$/, '')
+
+            // Cache file path always uses npm URI (never filesystem-relative paths)
+            const cacheFilePath = moduleUriWithoutExt
 
             const capsuleSourceLineRef = `${cacheFilePath}:${encapsulateOptions.importStackLine}`
 
@@ -297,7 +285,8 @@ export function StaticAnalyzer({
                                 timing?.record(`StaticAnalyzer: Cache HIT for ${encapsulateOptions.moduleFilepath}`)
                                 return {
                                     csts: cachedCsts,
-                                    crts: JSON.parse(crtsContent)
+                                    crts: JSON.parse(crtsContent),
+                                    moduleUri: moduleUriWithoutExt
                                 }
                             }
                         }
@@ -369,24 +358,12 @@ export function StaticAnalyzer({
                         continue
                     }
 
-                    const capsuleSourceLineRef = `${encapsulateOptions.moduleFilepath}:${encapsulateOptions.importStackLine}`
-                    const capsuleSourceNameRef = encapsulateOptions.capsuleName && `${encapsulateOptions.moduleFilepath}:${encapsulateOptions.capsuleName}`
+                    // Use npm URI for all CST references (never filesystem-relative paths)
+                    const capsuleSourceLineRef = `${moduleUriWithoutExt}:${encapsulateOptions.importStackLine}`
+                    const capsuleSourceNameRef = encapsulateOptions.capsuleName && `${moduleUriWithoutExt}:${encapsulateOptions.capsuleName}`
                     const capsuleSourceNameRefHash = capsuleSourceNameRef && createHash('sha256').update(capsuleSourceNameRef).digest('hex')
 
-                    // Construct npm URI for the module - try for all modules
-                    let moduleUri: string | null = await constructNpmUri(moduleFilepath, spineOptions.spineFilesystemRoot)
-
-                    // If npm URI construction failed, fall back to moduleFilepath
-                    if (!moduleUri) {
-                        moduleUri = encapsulateOptions.moduleFilepath
-                    }
-
-                    // Strip file extension from URI
-                    const moduleUriWithoutExt = moduleUri.replace(/\.(ts|tsx|js|jsx)$/, '')
-                    const capsuleSourceUriLineRef = `${moduleUriWithoutExt}:${encapsulateOptions.importStackLine}`
-
-                    // Store moduleUri without extension
-                    moduleUri = moduleUriWithoutExt
+                    const capsuleSourceUriLineRef = capsuleSourceLineRef
 
                     // Extract the capsule expression text from the source
                     const capsuleExpression = call.getText(sourceFile)
@@ -407,7 +384,7 @@ export function StaticAnalyzer({
                         capsuleSourceUriLineRef,
                         source: {
                             moduleFilepath: encapsulateOptions.moduleFilepath,
-                            moduleUri,
+                            moduleUri: moduleUriWithoutExt,
                             capsuleName: encapsulateOptions.capsuleName,
                             declarationLine,
                             importStackLine: encapsulateOptions.importStackLine,
@@ -760,6 +737,7 @@ export function StaticAnalyzer({
             return {
                 csts,
                 crts,
+                moduleUri: moduleUriWithoutExt
             }
         }
     }