@synopackageland/cli 0.3.10 → 0.4.1

package/templates/native-go-vue/frontend/src/nas/mock-provider.ts

@@ -0,0 +1,119 @@
+import {readActions, type DiscoveryAnchor, type FolderEntry, type GrantView, type NasProvider, type PickerContext, type PreparedIntent, type SafeCode, type ScopeKind} from './provider'
+
+// In-memory fixtures only. This does NOT validate DSM identity/ACL, implement
+// durable R/Q, issue protocol-2 tickets or connect a helper. Never use as auth.
+type Subject = 'admin' | 'normal1' | 'normal2'
+type Binding = {subject: Subject; session: number; epoch: number}
+type Browse = Binding & PickerContext & {canceled: boolean}
+type Candidate = Binding & FolderEntry & {contextId: string; scopeKind: ScopeKind; location: string; depth: number}
+type Intent = Binding & PreparedIntent & {candidateId: string; consumed: boolean}
+type Record = {owner: Subject; view: GrantView}
+function opaque() {return Array.from(crypto.getRandomValues(new Uint8Array(32)), b=>b.toString(16).padStart(2,'0')).join('')}
+function fail(code:SafeCode):never {throw {code}}
+function aborted(signal:AbortSignal) {if(signal.aborted) fail('canceled')}
+const clone = <T>(value:T):T => JSON.parse(JSON.stringify(value))
+
+export function createMockNasService(options:{now?:()=>number; drained?:boolean; appName?:string; pageSize?:number; homeAvailable?:boolean; personalFolders?:readonly string[]} = {}) {
+ const now=options.now ?? Date.now
+ const subjects = new Map<Subject, {session:number; admin:boolean}>([['admin',{session:1,admin:true}],['normal1',{session:1,admin:false}],['normal2',{session:1,admin:false}]])
+ const contexts=new Map<string,Browse>(), candidates=new Map<string,Candidate>(), intents=new Map<string,Intent>(), records=new Map<string,Record>()
+ const cursors=new Map<string,Binding & {contextId:string; nodeId?:string; offset:number}>()
+ // References have S1's shape but are synthetic fixtures, not native proofs.
+ const principals = new Map([...subjects.keys()].map(subject=>[subject,{kind:'local' as const,subjectRef:opaque(),instanceRef:opaque()}]))
+ const epoch={value:1}
+ function connect(subject:Subject):NasProvider {
+  const actor=()=>subjects.get(subject)!
+  const binding=():Binding=>({subject,session:actor().session,epoch:epoch.value})
+  function check(b:Binding) {
+   if(b.subject!==subject) fail('denied')
+   if(b.session!==actor().session || b.epoch!==epoch.value) fail('stale')
+  }
+  function browse(id:string) {
+   const ctx=contexts.get(id); if(!ctx) fail('denied'); check(ctx)
+   if(ctx.canceled) fail('canceled')
+   if(now()>=ctx.expiresAt) fail('expired')
+   if(ctx.scopeKind==='app-shared' && !actor().admin) fail('denied')
+   return ctx
+  }
+  function candidate(id:string) {
+   const node=candidates.get(id); if(!node) fail('denied'); check(node); browse(node.contextId)
+   return node
+  }
+  function entry(ctx:Browse, displayName:string, depth:number, parent?:Candidate):Candidate {
+   const node:Candidate={...binding(),contextId:ctx.contextId,scopeKind:ctx.scopeKind,nodeId:opaque(),displayName,targetKind:'directory',selectable:true,depth,location:parent?`${parent.location} / ${displayName}`:`${ctx.scopeKind==='user-personal'?'My home':'Shared folders'} / ${displayName}`}
+   candidates.set(node.nodeId,node); return node
+  }
+  const visible=()=>[...records.values()].filter(r=>r.owner===subject || r.view.scopeKind==='app-shared').map(r=>({...clone(r.view),canRevoke:r.view.scopeKind==='app-shared'?actor().admin:r.owner===subject}))
+  const provider:NasProvider = {
+   mode:'mock',
+   async begin(scopeKind,signal) {
+    aborted(signal)
+    if(!['user-personal','app-shared'].includes(scopeKind)) fail('invalid-request')
+    if(scopeKind==='app-shared' && !actor().admin) fail('denied')
+    if(scopeKind==='user-personal' && options.homeAvailable===false) fail('unavailable')
+    // Bound retained fixtures; never evict unexpired replay/intent state.
+    if(contexts.size>=256) fail('limit-exceeded')
+    const ctx:Browse={...binding(),contextId:opaque(),scopeKind,expiresAt:now()+60_000,canceled:false}
+    contexts.set(ctx.contextId,ctx)
+    return {contextId:ctx.contextId,scopeKind,expiresAt:ctx.expiresAt}
+   },
+   async list(contextId,nodeId,cursor,signal) {
+    aborted(signal); const ctx=browse(contextId), parent=nodeId?candidate(nodeId):undefined
+    if(parent && parent.contextId!==contextId) fail('denied')
+    let offset=0
+    if(cursor) {
+     const c=cursors.get(cursor); if(!c) fail('denied'); check(c)
+     if(c.contextId!==contextId || c.nodeId!==nodeId) fail('denied'); offset=c.offset
+    }
+    // Own home never returns a selectable home root. Only subdirectories do.
+    // Shared discovery first supplies S1 anchor metadata; no absolute paths.
+    const anchors:DiscoveryAnchor[]=[{ref:opaque(),displayName:'Team documents',kind:ctx.scopeKind,owner:principals.get(subject)!,localFilesystem:true}]
+    const names=parent?(parent.displayName==='Empty folder' || parent.depth>=2?[]:['Reports']):(ctx.scopeKind==='user-personal'?(options.personalFolders ?? ['Projects','Empty folder']):anchors.map(a=>a.displayName))
+    const size=Math.max(1,Math.min(200,options.pageSize ?? 200)), slice=names.slice(offset,offset+size)
+    const entries=slice.map(name=>{
+     const n=entry(ctx,name,(parent?.depth ?? 0)+1,parent)
+     return {nodeId:n.nodeId,displayName:n.displayName,targetKind:n.targetKind,selectable:n.selectable}
+    })
+    let nextCursor:string|undefined
+    if(offset+size<names.length) {nextCursor=opaque();cursors.set(nextCursor,{...binding(),contextId,nodeId,offset:offset+size})}
+    return {entries,nextCursor}
+   },
+   async prepare(candidateId,signal) {
+    aborted(signal);const node=candidate(candidateId)
+    if(!node.selectable) fail('denied')
+    if([...intents.values()].filter(i=>i.subject===subject && !i.consumed && i.expiresAt>now() && !contexts.get(candidates.get(i.candidateId)!.contextId)!.canceled).length>=8) fail('limit-exceeded')
+    const intent:Intent={...binding(),intentId:opaque(),candidateId,consumed:false,summaryDigest:opaque(),expiresAt:now()+30_000,summary:{appName:options.appName ?? 'Mock package',scopeKind:node.scopeKind,displayName:node.location,targetKind:'directory',actions:[...readActions],persistent:true}}
+    // Synthetic digest-shaped token bound to this immutable fixture summary;
+    // the real S3 adapter must supply its actual exact-summary digest.
+    intents.set(intent.intentId,intent);return clone({intentId:intent.intentId,summaryDigest:intent.summaryDigest,expiresAt:intent.expiresAt,summary:intent.summary})
+   },
+   async confirm(intentId,summaryDigest,signal) {
+    aborted(signal);const intent=intents.get(intentId);if(!intent) fail('denied');check(intent)
+    if(intent.consumed) fail('replay')
+    if(now()>=intent.expiresAt) fail('expired')
+    if(summaryDigest!==intent.summaryDigest) fail('stale')
+    const node=candidate(intent.candidateId)
+    if(node.scopeKind==='app-shared' && !actor().admin) fail('denied')
+    if(records.size>=256) fail('limit-exceeded')
+    intent.consumed=true
+    const view:GrantView={grantId:opaque(),revision:1,scopeKind:node.scopeKind,displayName:node.location,targetKind:'directory',actions:[...readActions],effectiveState:'active',createdAt:now(),canRevoke:true}
+    records.set(view.grantId,{owner:subject,view});return clone(view)
+   },
+   async cancel(contextId) {
+    const ctx=contexts.get(contextId);if(!ctx) return;check(ctx);ctx.canceled=true
+   },
+   async grants(signal) {aborted(signal);return visible()},
+   async settings(signal) {aborted(signal);return {items:visible(),canManageShared:actor().admin}},
+   async revoke(grantId,revision,signal) {
+    aborted(signal);const record=records.get(grantId);if(!record) fail('denied')
+    if(record.view.scopeKind==='app-shared'?!actor().admin:record.owner!==subject) fail('denied')
+    if(record.view.revision!==revision) fail('stale')
+    if(record.view.effectiveState!=='revoked') {record.view.revision++;record.view.effectiveState='revoked'}
+    record.view.drained=options.drained ?? true
+    return {grantId,grantRevision:record.view.revision,revoked:true,drained:record.view.drained}
+   },
+  }
+  return provider
+ }
+ return {connect,setAdmin(subject:Subject,admin:boolean){subjects.get(subject)!.admin=admin},invalidate(subject:Subject){subjects.get(subject)!.session++},newEpoch(){epoch.value++;for(const r of records.values()) if(r.view.effectiveState==='active') r.view.effectiveState='suspended'}}
+}

package/templates/native-go-vue/frontend/src/nas/provider.ts

@@ -0,0 +1,59 @@
+import type {InjectionKey} from 'vue'
+
+// S0 protocol-2 display projections, not root Grant/Intent authority records.
+// IDs index provider-owned mappings. No paths, credentials, UID or role claims
+// travel in picker/consent arguments. S1 discovery metadata is not a grant.
+export type ScopeKind = 'app-shared' | 'user-personal'
+export const readActions = ['nas.files.list', 'nas.files.stat', 'nas.files.read'] as const
+export type ReadAction = typeof readActions[number]
+export type SafeCode = 'unknown_method' | 'session_required' | 'auth_unavailable' | 'invalid-request' | 'incompatible' | 'unsupported' | 'replay' | 'stale' | 'expired' | 'denied' | 'unavailable' | 'suspended' | 'revoked' | 'fenced' | 'busy' | 'limit-exceeded' | 'canceled' | 'timeout' | 'partial' | 'commit-uncertain' | 'cleanup-required' | 'internal'
+export interface SafeError {code: SafeCode; operationId?: string}
+export interface DiscoveryAnchor {
+ ref: string
+ displayName: string
+ kind: ScopeKind
+ owner: {kind: 'local'; subjectRef: string; instanceRef: string}
+ localFilesystem: boolean
+}
+export interface PickerContext {contextId: string; scopeKind: ScopeKind; expiresAt: number}
+export interface FolderEntry {nodeId: string; displayName: string; targetKind: 'directory'; selectable: boolean}
+export interface FolderPage {entries: FolderEntry[]; nextCursor?: string}
+export interface ConsentSummary {
+ appName: string
+ scopeKind: ScopeKind
+ displayName: string
+ targetKind: 'directory'
+ actions: readonly ReadAction[]
+ persistent: true
+}
+export interface PreparedIntent {intentId: string; summaryDigest: string; expiresAt: number; summary: ConsentSummary}
+export interface GrantHandle {
+ grantId: string
+ revision: number
+ scopeKind: ScopeKind
+ displayName: string
+ targetKind: 'directory'
+ actions: readonly ReadAction[]
+}
+export interface GrantView extends GrantHandle {
+ effectiveState: 'active' | 'suspended' | 'revoked'
+ createdAt: number
+ canRevoke: boolean
+ // S0 R/Q receipt: undefined means Q has not been observed, never assume true.
+ drained?: boolean
+ cleanupRequired?: boolean
+}
+export interface GrantList {items: GrantView[]; canManageShared: boolean}
+export interface RevokeResult {grantId: string; grantRevision: number; revoked: boolean; drained: boolean}
+export interface NasProvider {
+ readonly mode: 'mock' | 'connected'
+ begin(kind: ScopeKind, signal: AbortSignal): Promise<PickerContext>
+ list(contextId: string, nodeId: string | undefined, cursor: string | undefined, signal: AbortSignal): Promise<FolderPage>
+ prepare(candidateId: string, signal: AbortSignal): Promise<PreparedIntent>
+ confirm(intentId: string, summaryDigest: string, signal: AbortSignal): Promise<GrantHandle>
+ cancel(contextId: string): Promise<void>
+ grants(signal: AbortSignal): Promise<GrantView[]>
+ settings(signal: AbortSignal): Promise<GrantList>
+ revoke(grantId: string, revision: number, signal: AbortSignal): Promise<RevokeResult>
+}
+export const NasProviderKey: InjectionKey<NasProvider> = Symbol('nas-provider')

package/templates/native-go-vue/frontend/src/nas/use-request.ts

@@ -0,0 +1,27 @@
+import {onBeforeUnmount, ref} from 'vue'
+
+// One admission at a time per component, bounded metadata requests, and no late
+// responses after close/unmount. An abort is not a server rollback/Q receipt.
+export function useNasRequest() {
+ const busy=ref(false), error=ref<unknown>()
+ let generation=0, disposed=false, controller:AbortController|undefined
+ function cancel() {generation++;controller?.abort();controller=undefined;busy.value=false;error.value=undefined}
+ async function run<T>(operation:(signal:AbortSignal,current:()=>boolean)=>Promise<T>):Promise<T|undefined> {
+  if(busy.value || disposed) return
+  const version=++generation, active=new AbortController();controller=active;busy.value=true;error.value=undefined
+  const current=()=>!disposed && generation===version
+  let timer:ReturnType<typeof setTimeout>|undefined
+  let onAbort:()=>void=()=>{}
+  try {
+   const stop=new Promise<never>((_,reject)=> {
+    onAbort=()=>reject({code:'canceled'});active.signal.addEventListener('abort',onAbort,{once:true})
+    timer=setTimeout(()=>{reject({code:'timeout'});active.abort()},5000)
+   })
+   const value=await Promise.race([operation(active.signal,current),stop])
+   return current()?value:undefined
+  } catch(e) {if(current()) error.value=e;return undefined}
+  finally {clearTimeout(timer);active.signal.removeEventListener('abort',onAbort);if(current()){busy.value=false;controller=undefined}}
+ }
+ onBeforeUnmount(()=>{disposed=true;cancel()})
+ return {busy,error,run,cancel}
+}

package/templates/native-go-vue/frontend/src/style.css

@@ -0,0 +1,31 @@
+.dsmapp-vue-root {height: 100%; min-height: 0; width: 100%; overflow: hidden;}
+[data-ui-app] .integration-app {padding: var(--ui-space-5, 20px); max-width: 72ch; color: var(--ui-text); font-family: var(--ui-font-sans); font-size: 13px; line-height: 1.5;}
+[data-ui-app] .integration-heading {display: flex; align-items: center; justify-content: space-between; gap: 16px; margin-bottom: 20px;}
+[data-ui-app] .integration-heading h1 {font-size: 20px; font-weight: 600; margin: 0;}
+[data-ui-app] .integration-heading p {color: var(--ui-text); margin: 4px 0 0;}
+[data-ui-app] .integration-app section {margin-top: 24px;}
+[data-ui-app] .integration-status h2 {font-size: 15px; font-weight: 600; margin: 0;}
+[data-ui-app] .integration-status p {margin: 6px 0;}
+[data-ui-app] .integration-status dl {display: grid; grid-template-columns: max-content 1fr; gap: 4px 16px; margin: 12px 0;}
+[data-ui-app] .integration-status dt, [data-ui-app] .integration-help {color: var(--ui-text);}
+[data-ui-app] .integration-status dd {margin: 0;}
+[data-ui-app] .integration-actions {display: flex; flex-wrap: wrap; gap: 8px; margin-top: 16px;}
+[data-ui-app] .integration-field {display: grid; gap: 6px; margin: 12px 0;}
+[data-ui-app] .integration-notice {color: var(--ui-text);}
+[data-ui-app] .nas-summary {display: grid; grid-template-columns: minmax(6ch, max-content) minmax(0, 1fr); gap: var(--ui-space-2, 8px) var(--ui-space-4, 16px);}
+[data-ui-app] .nas-summary dd {margin: 0; overflow-wrap: anywhere;}
+[data-ui-app] .nas-breadcrumb {display: flex; flex-wrap: wrap; gap: var(--ui-space-2, 8px); margin-block: var(--ui-space-3, 12px);}
+[data-ui-app] .nas-browser {display: grid; grid-template-columns: minmax(0, 1fr); gap: var(--ui-space-3, 12px);}
+[data-ui-app] .nas-tree {display: none;}
+[data-ui-app] .nas-folder-list {min-width: 0; overflow: auto;}
+[data-ui-app] .nas-folder-name {white-space: normal; overflow-wrap: anywhere; text-align: start;}
+[data-ui-app] .nas-folder-action {white-space: normal; max-width: 100%;}
+[data-ui-app] .nas-picker {max-height: 55vh; overflow: auto; overflow-wrap: anywhere;}
+[data-ui-app] .nas-grants {list-style: none; padding: 0;}
+[data-ui-app] .nas-grants > li {padding-block: var(--ui-space-4, 16px); border-bottom: 1px solid var(--ui-border);}
+[data-ui-app] .nas-grant-heading {display: flex; align-items: start; justify-content: space-between; gap: var(--ui-space-3, 12px);}
+[data-ui-app] .nas-grant-heading strong {overflow-wrap: anywhere;}
+@media (min-width: 960px) {
+ [data-ui-app] .nas-browser {grid-template-columns: minmax(8ch, 1fr) minmax(0, 3fr);}
+ [data-ui-app] .nas-tree {display: block; overflow: auto;}
+}

package/templates/native-go-vue/frontend/test/apps.test.ts

@@ -0,0 +1,190 @@
+// @vitest-environment jsdom
+import {expect, test, vi} from 'vitest'
+import {nextTick} from 'vue'
+import {mount} from '../src/main'
+import {nasCopy} from '../src/nas/i18n'
+import type {Context, IntegrationState} from '../src/context'
+
+function fixture(id: string, admin: boolean, state: IntegrationState = 'ready') {
+ const reopen: Array<() => void> = []
+ const call = vi.fn(async (method: string) => {
+  if(method === 'app.status') return {package: id, version:'0.1.0-0001',user:admin?'admin':'normal1',admin}
+  if(method === 'integration.status') return {state,reason:'fixture',packageRunning:'unknown',scheduler:'not-probed'}
+  if(method === 'personal.list') return {items:[{id:`${id}-private`,name:'My sample note'}]}
+  if(method === 'personal.read') return {id:`${id}-private`,text:`Private ${id}`}
+  throw {code:'unknown_method'}
+ })
+ const ctx = {call,reopen:(fn:()=>void)=>reopen.push(fn),locale:'en',root:{state:vi.fn(async()=> 'missing'),authorize:vi.fn(async()=> 'ready'),run:vi.fn(async()=>{}),remove:vi.fn(async()=> 'missing')}} as Context
+ const root=document.createElement('div');document.body.append(root)
+ const app=mount(root,ctx)
+ return {root,app,ctx,call,reopen}
+}
+async function settle(){for(let i=0;i<12;i++){await Promise.resolve();await nextTick()}await new Promise(resolve=>setTimeout(resolve,25))}
+function click(root:HTMLElement,text:string){const node=[...root.querySelectorAll('button')].find(node=>node.textContent?.trim()===text);expect(node, text).toBeTruthy();node!.click()}
+
+test('seven states and ordinary-user errors give actionable status without approval controls',async()=>{
+ for(const state of ['not-enabled','ready','needs-approval','incompatible','stopped','failed','pending'] as IntegrationState[]){
+  const f=fixture('Ordinary',false,state);await settle()
+  expect(f.root.querySelector('[data-integration-state]')?.getAttribute('data-integration-state')).toBe(state)
+  expect(f.root.textContent).not.toContain('Approve and activate')
+  f.app.unmount();f.root.remove()
+ }
+})
+test('approval cancellation never runs the root task and all fixed controls recheck status',async()=>{
+ const f=fixture('Admin',true,'needs-approval');await settle()
+ f.ctx.root!.authorize=vi.fn(async()=> 'cancelled')
+ click(f.root,'Approve and activate');await settle()
+ expect(f.ctx.root!.run).not.toHaveBeenCalled()
+ expect(f.root.textContent).toContain('Approval cancelled')
+ f.ctx.root!.authorize=vi.fn(async()=> 'ready')
+ click(f.root,'Approve and activate');await settle()
+ expect(f.ctx.root!.run).toHaveBeenCalledWith('helper_enable')
+ for(const [label,op] of [['Recover','helper_recover'],['Teardown','helper_teardown']] as const){click(f.root,label);await settle();expect(f.ctx.root!.run).toHaveBeenCalledWith(op)}
+ click(f.root,'Disable');await settle();click(f.root,'Confirm disable');await settle();expect(f.ctx.root!.run).toHaveBeenCalledWith('helper_disable')
+ f.app.unmount();f.root.remove()
+})
+test('two generated package IDs keep mounts, reopen events, overlays and unmount independent',async()=>{
+ const a=fixture('M1bAlpha',true),b=fixture('M1bBeta',true);await settle()
+ expect(a.root.textContent).toContain('M1bAlpha');expect(a.root.textContent).not.toContain('M1bBeta')
+ expect(b.root.textContent).toContain('M1bBeta')
+ click(a.root,'Disable');await settle()
+ expect(a.root.querySelector('[role="dialog"]')).toBeTruthy()
+ expect(b.root.querySelector('[role="dialog"]')).toBeNull()
+ const ac=a.call.mock.calls.length,bc=b.call.mock.calls.length
+ a.reopen.forEach(fn=>fn());await settle();expect(a.call.mock.calls.length).toBeGreaterThan(ac);expect(b.call.mock.calls.length).toBe(bc)
+ a.app.unmount();await settle();expect(a.root.childElementCount).toBe(0)
+ const count=a.call.mock.calls.length;a.reopen.forEach(fn=>fn());await settle();expect(a.call.mock.calls.length).toBe(count)
+ b.reopen.forEach(fn=>fn());await settle();expect(b.call.mock.calls.length).toBeGreaterThan(bc)
+ b.app.unmount();a.root.remove();b.root.remove()
+})
+
+test('first-load errors replace loading text with an explicit retry state',async()=>{
+ const root=document.createElement('div');document.body.append(root)
+ const ctx={locale:'en',reopen(){},call:vi.fn(async()=>{throw {code:'auth_unavailable'}})} as Context
+ const app=mount(root,ctx);await settle()
+ expect(root.textContent).toContain('Status could not be loaded')
+ expect(root.textContent).not.toContain('Loading integration status')
+ app.unmount();root.remove()
+})
+test('a ready integration with no sample handle shows an explicit empty state',async()=>{
+ const f=fixture('Empty',false)
+ f.call.mockImplementation(async(method:string)=> {
+  if(method==='app.status')return {package:'Empty',version:'0.1.0',user:'normal1',admin:false}
+  if(method==='integration.status')return {state:'ready',packageRunning:'unknown',scheduler:'not-probed'}
+  if(method==='personal.list')return {items:[]}
+  throw {code:'unknown_method'}
+ })
+ f.reopen.forEach(fn=>fn());await settle()
+ // Reopen once after the initial in-flight refresh has finished.
+ f.reopen.forEach(fn=>fn());await settle()
+ expect(f.root.textContent).toContain('No sample data')
+ f.app.unmount();f.root.remove()
+})
+
+test('root failure diagnostics survive the required post-failure status refresh',async()=>{
+ const f=fixture('RootFailure',true,'needs-approval');await settle()
+ f.ctx.root!.run=vi.fn(async()=>{throw {code:'root_run_failed'}})
+ click(f.root,'Approve and activate');await settle()
+ expect(f.root.textContent).toContain('The approved operation failed')
+ expect(f.call.mock.calls.filter(args=>args[0]==='integration.status').length).toBeGreaterThan(1)
+ f.app.unmount();f.root.remove()
+})
+
+test('a local modal leaves the other mount interactive and preserves host styles',async()=>{
+ const a=fixture('M1bAlpha',true),b=fixture('M1bBeta',true)
+ const body=document.body.getAttribute('style'),html=document.documentElement.getAttribute('style')
+ try {
+  await settle();click(a.root,'Disable');await settle()
+  const dialog=a.root.querySelector('[role="dialog"]')!
+  expect(dialog).toBeTruthy()
+  expect(dialog.hasAttribute('aria-modal')).toBe(false)
+  expect(b.root.querySelector('.integration-app')!.closest('[inert], [aria-hidden="true"]')).toBeNull()
+  expect(getComputedStyle(b.root).pointerEvents).not.toBe('none')
+  expect(document.body.getAttribute('style')).toBe(body)
+  expect(document.documentElement.getAttribute('style')).toBe(html)
+  const before=b.call.mock.calls.length
+  click(b.root,'Refresh');await settle()
+  expect(b.call.mock.calls.length).toBeGreaterThan(before)
+  click(b.root,'Disable');await settle()
+  expect(a.root.querySelector('[role="dialog"]')).toBeTruthy()
+  expect(b.root.querySelector('[role="dialog"]')).toBeTruthy()
+  click(a.root,'Cancel');await settle()
+  expect(a.root.querySelector('[role="dialog"]')).toBeNull()
+  expect(b.root.querySelector('[role="dialog"]')).toBeTruthy()
+  expect(a.root.querySelector('.integration-app')!.closest('[inert], [aria-hidden="true"]')).toBeNull()
+ } finally {
+  a.app.unmount();b.app.unmount();a.root.remove();b.root.remove();await settle()
+ }
+ expect(document.body.getAttribute('style')).toBe(body)
+ expect(document.documentElement.getAttribute('style')).toBe(html)
+})
+
+test('repeated mounts of the same package use unique, package-prefixed ARIA references',async()=>{
+ const a=fixture('SamePackage',true),b=fixture('SamePackage',true)
+ try {
+  await settle();click(a.root,'Disable');click(b.root,'Disable');await settle()
+  const ids=[...document.querySelectorAll('[id]')].map(node=>node.id).filter(Boolean)
+  expect(new Set(ids).size).toBe(ids.length)
+  for(const f of [a,b]) {
+   const dialog=f.root.querySelector('[role="dialog"]')!
+   for(const attr of ['aria-labelledby','aria-describedby']) {
+    const id=dialog.getAttribute(attr)!
+    // CLI substitutes the package ID in this template before building.
+    expect(id).toContain('__PACKAGE__-')
+    expect(f.root.querySelector(`[id="${id}"]`)).toBeTruthy()
+   }
+  }
+ } finally {a.app.unmount();b.app.unmount();a.root.remove();b.root.remove();await settle()}
+})
+
+test('unmount releases its sizing class and preserves an existing host class',async()=>{
+ const f=fixture('Sizing',false)
+ expect(f.root.classList.contains('dsmapp-vue-root')).toBe(true)
+ f.app.unmount()
+ expect(f.root.classList.contains('dsmapp-vue-root')).toBe(false)
+ f.root.classList.add('dsmapp-vue-root')
+ const app=mount(f.root,f.ctx);await settle();app.unmount()
+ expect(f.root.classList.contains('dsmapp-vue-root')).toBe(true)
+ f.root.remove()
+})
+
+test('repair is administrator-only and cancellation or refusal never starts recovery',async()=>{
+ const user=fixture('UserRepair',false,'failed'),admin=fixture('AdminRepair',true,'failed')
+ try {
+  await settle()
+  expect(user.root.textContent).not.toContain('Repair cleanup')
+  admin.ctx.root!.authorize=vi.fn(async()=> 'cancelled')
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.ctx.root!.authorize).toHaveBeenCalledWith('helper_repair')
+  expect(admin.ctx.root!.run).not.toHaveBeenCalled()
+  admin.ctx.root!.authorize=vi.fn(async()=> 'ready')
+  admin.ctx.root!.run=vi.fn(async()=>{throw {code:'root_task_failed'}})
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.ctx.root!.run).toHaveBeenCalledWith('helper_repair')
+  expect(admin.ctx.root!.run).not.toHaveBeenCalledWith('helper_recover')
+  expect(admin.root.textContent).toContain('Repair could not verify safe cleanup')
+  expect(admin.call.mock.calls.filter(args=>args[0]==='integration.status').length).toBeGreaterThan(1)
+  admin.ctx.root!.run=vi.fn(async()=>{throw {code:'root_cancelled'}})
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.root.textContent).toContain('Repair confirmation cancelled. No operation was run.')
+  admin.ctx.root!.run=vi.fn(async()=>{})
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.root.textContent).toContain('Cleanup repaired. Use Recover or Approve and activate')
+  expect(admin.ctx.root!.run).not.toHaveBeenCalledWith('helper_recover')
+ } finally {user.app.unmount();admin.app.unmount();user.root.remove();admin.root.remove()}
+})
+
+ test('pending health shows localized waiting copy without exposing sample authority',async()=>{
+ const locales=['en','zh-TW','zh-CN','ja','ko','de','fr','es','it']
+ for(const locale of locales){
+  const f=fixture('Pending',false,'pending');f.ctx.locale=locale
+  f.reopen.forEach(fn=>fn());await settle()
+  expect(f.root.querySelector('[data-integration-state="pending"]')).toBeTruthy()
+  expect(f.root.textContent).not.toContain('Administrator action needed')
+  expect(f.root.textContent).not.toContain('My sample data')
+  expect(f.call.mock.calls.some(args=>args[0]==='personal.list')).toBe(false)
+  expect(f.root.querySelector('.integration-status h2')?.textContent?.trim()).toBe(nasCopy(locale).healthPending)
+  expect(f.root.textContent).toContain(nasCopy(locale).healthPendingHelp)
+  f.app.unmount();f.root.remove()
+ }
+})

package/templates/native-go-vue/frontend/test/nas-provider.test.ts

@@ -0,0 +1,81 @@
+import {expect, test} from 'vitest'
+import {createMockNasService} from '../src/nas/mock-provider'
+
+const signal = () => new AbortController().signal
+async function selection(provider: ReturnType<ReturnType<typeof createMockNasService>['connect']>) {
+ const context = await provider.begin('user-personal', signal())
+ const page = await provider.list(context.contextId, undefined, undefined, signal())
+ return {context, candidate: page.entries[0]!}
+}
+
+test('two ordinary subjects cannot exchange contexts, candidates, intents or personal grants', async () => {
+ const service = createMockNasService(), a = service.connect('normal1'), b = service.connect('normal2')
+ const picked = await selection(a)
+ await expect(b.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'denied'})
+ await expect(b.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'denied'})
+ const intent = await a.prepare(picked.candidate.nodeId, signal())
+ await expect(b.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'denied'})
+ const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
+ expect(await b.grants(signal())).toEqual([])
+ await expect(b.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
+ expect(grant.actions).toEqual(['nas.files.list','nas.files.stat','nas.files.read'])
+ expect(JSON.stringify(grant)).not.toMatch(/\/volume|uid|sessionRef/)
+})
+
+test('intent expires at 30 seconds; candidate expires at 60; cancel never creates a grant', async () => {
+ let now = 1000
+ const service = createMockNasService({now:() => now}), a = service.connect('normal1')
+ const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
+ now += 30_000
+ await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'expired'})
+ now += 30_000
+ await expect(a.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'expired'})
+ const next = await selection(a), cancelIntent = await a.prepare(next.candidate.nodeId, signal())
+ await a.cancel(next.context.contextId)
+ await expect(a.confirm(cancelIntent.intentId, cancelIntent.summaryDigest, signal())).rejects.toEqual({code:'canceled'})
+ expect(await a.grants(signal())).toEqual([])
+})
+
+test('summary mismatch, replay, abort, role and session changes refuse; reconfirm gets a new ID', async () => {
+ const service = createMockNasService(), admin = service.connect('admin'), a = service.connect('normal1')
+ await expect(a.begin('app-shared', signal())).rejects.toEqual({code:'denied'})
+ const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
+ await expect(a.confirm(intent.intentId, '0'.repeat(64), signal())).rejects.toEqual({code:'stale'})
+ const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
+ await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'replay'})
+ await a.revoke(grant.grantId, grant.revision, signal())
+ const second = await a.prepare(picked.candidate.nodeId, signal())
+ expect((await a.confirm(second.intentId, second.summaryDigest, signal())).grantId).not.toBe(grant.grantId)
+ const aborted = new AbortController(); aborted.abort()
+ await expect(a.begin('user-personal', aborted.signal)).rejects.toEqual({code:'canceled'})
+ const context = await admin.begin('app-shared', signal()), page = await admin.list(context.contextId, undefined, undefined, signal())
+ const shared = await admin.prepare(page.entries[0]!.nodeId, signal())
+ service.setAdmin('admin', false)
+ await expect(admin.confirm(shared.intentId, shared.summaryDigest, signal())).rejects.toEqual({code:'denied'})
+ service.invalidate('normal1')
+ await expect(a.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'stale'})
+})
+
+test('shared grant discovery is visible without becoming revoke authority; R and Q stay separate', async () => {
+ const service = createMockNasService({drained:false}), admin = service.connect('admin'), a = service.connect('normal1')
+ const ctx = await admin.begin('app-shared', signal()), page = await admin.list(ctx.contextId, undefined, undefined, signal())
+ const intent = await admin.prepare(page.entries[0]!.nodeId, signal()), grant = await admin.confirm(intent.intentId, intent.summaryDigest, signal())
+ expect((await a.grants(signal()))[0]?.grantId).toBe(grant.grantId)
+ await expect(a.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
+ expect(await admin.revoke(grant.grantId, grant.revision, signal())).toMatchObject({revoked:true,drained:false})
+})
+
+test('pagination binds cursor to actor/context/node and revision CAS rejects stale revoke',async()=> {
+ const service=createMockNasService({pageSize:1}), a=service.connect('normal1'), b=service.connect('normal2')
+ const {context,candidate}=await selection(a)
+ const page=await a.list(context.contextId,undefined,undefined,signal())
+ expect(page.entries).toHaveLength(1);expect(page.nextCursor).toBeTruthy()
+ expect((await a.list(context.contextId,undefined,page.nextCursor,signal())).entries[0]!.displayName).toBe('Empty folder')
+ await expect(a.list(context.contextId,candidate.nodeId,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
+ await expect(b.list(context.contextId,undefined,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
+ const intent=await a.prepare(candidate.nodeId,signal()), grant=await a.confirm(intent.intentId,intent.summaryDigest,signal())
+ await expect(a.revoke(grant.grantId,grant.revision+1,signal())).rejects.toEqual({code:'stale'})
+ service.newEpoch()
+ expect((await a.grants(signal()))[0]!.effectiveState).toBe('suspended')
+ await expect(a.prepare(candidate.nodeId,signal())).rejects.toEqual({code:'stale'})
+})

package/templates/native-go-vue/frontend/test/nas-request.test.ts

@@ -0,0 +1,21 @@
+// @vitest-environment jsdom
+import {expect,test,vi} from 'vitest'
+import {createApp,defineComponent} from 'vue'
+import {useNasRequest} from '../src/nas/use-request'
+
+test('unresponsive discovery times out in five seconds, aborts, and ignores late metadata',async()=> {
+ vi.useFakeTimers()
+ let request!:ReturnType<typeof useNasRequest>
+ const root=document.createElement('div')
+ const app=createApp(defineComponent({setup(){request=useNasRequest();return ()=>null}}));app.mount(root)
+ try {
+  let resolve!:(s:string)=>void, signal!:AbortSignal
+  const pending=request.run(s=>{signal=s;return new Promise<string>(r=>resolve=r)})
+  await vi.advanceTimersByTimeAsync(5000)
+  expect(await pending).toBeUndefined()
+  expect(request.busy.value).toBe(false);expect(signal.aborted).toBe(true)
+  expect(request.error.value).toEqual({code:'timeout'})
+  resolve('late private metadata');await Promise.resolve()
+  expect(request.error.value).toEqual({code:'timeout'})
+ } finally {app.unmount();vi.useRealTimers()}
+})