@choiceapps/communityservices-sdk 0.1.0

package/browser/need-recording.d.mts

@@ -0,0 +1,37 @@
+import type {Page} from 'playwright-core';
+import type {UiMutationStore} from './index.mjs';
+export interface IndependentNeedInput {
+ /** Stable upstream event ID. Reuse with identical intent and durable store after failures. */
+ key:string;clientId:number;providerId:number;serviceCodeId:number;
+ /** Timezone-qualified instant, precision to whole seconds. No REST/mobile offset correction. */
+ needDate:string;status:string;outcome:string;reasonUnmet?:string|null;note?:string;amount?:number|null;
+}
+export interface IndependentNeedValues {clientId:number;providerId:number;serviceCodeId:number;needDate:string;status:string;outcome:string;reasonUnmet:string|null;note:string;amount:number|null;}
+export interface IndependentNeedRecord extends IndependentNeedValues {needId:number;serviceCount:number;}
+export interface ServiceTypeOption {serviceCodeId:number;code:string;description:string;codeSetId:number;parentServiceCodeId:number|null;}
+export interface ServiceTypeCatalog {
+ codeSets:{id:number;name:string}[];
+ /** Tenant-wide active assignable types. Not provider quicklists or service eligibility. */
+ types:ServiceTypeOption[];
+}
+export interface ServiceQuicklist {
+ providerId:number;types:ServiceTypeOption[];
+ needOptions:{statuses:{value:string;label:string}[];outcomes:{value:string;label:string}[];unmetReasons:{value:string;label:string}[]};
+}
+export interface IndependentNeedUi {
+ list(context:{clientId:number}):Promise<IndependentNeedRecord[]>;
+ /** Adapter must call beforeSave immediately before its one save, never retry the click. */
+ create(values:IndependentNeedValues,beforeSave:()=>Promise<void>):Promise<void>;
+}
+export interface NeedUi extends IndependentNeedUi {
+ readonly connection:import("./connection.mjs").UiConnection;
+ /** Both services and needs use this AIRS/service-code catalog; client supplies UI context only. */
+ listServiceTypes(context:{clientId:number}):Promise<ServiceTypeCatalog>;
+ /** Small provider/program quicklist read; does not enumerate the full tenant taxonomy. */
+ listServiceQuicklist(context:{clientId:number;providerId:number}):Promise<ServiceQuicklist>;
+}
+export interface IndependentNeedResult {key:string;need:IndependentNeedRecord;outcome:'verified'|'reconciled'|'already-present';}
+export interface NeedRecorder {record(input:IndependentNeedInput):Promise<IndependentNeedResult>;}
+export class NeedConflictError extends Error {readonly code:'NEED_CONFLICT';readonly reason:string;constructor(reason:string);}
+export function createNeedRecorder(options:{store:UiMutationStore}&({ui:IndependentNeedUi;tenant:string}|{ui:IndependentNeedUi&{readonly connection:import("./connection.mjs").UiConnection};tenant?:string})):NeedRecorder;
+export function createNeedUi(options:{page:Page}):NeedUi;

package/browser/need-recording.mjs

@@ -0,0 +1,68 @@
+import {validateTenant} from './connection.mjs';
+import {createHash} from 'node:crypto';
+const hash=value=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const id=value=>{if(!Number.isSafeInteger(value)||value<1)throw Error('Positive integer ID required');return value;};
+const text=(value,name,limit)=>{if(typeof value!=='string'||!value.trim()||value.length>limit||/[\0\r]/.test(value))throw Error(`Invalid ${name}`);return value;};
+export class NeedConflictError extends Error {
+ constructor(reason){super(`Independent need conflict: ${reason}`);this.name='NeedConflictError';this.code='NEED_CONFLICT';this.reason=reason;}
+}
+/** Validate before opening a form or touching the durable journal. */
+export function normalizeNeedInput(input){
+ if(!input||Object.keys(input).some(k=>!['key','clientId','providerId','serviceCodeId','needDate','status','outcome','reasonUnmet','note','amount'].includes(k)))throw Error('Unsupported independent need input');
+ const key=text(input.key,'source key',200),clientId=id(input.clientId),providerId=id(input.providerId),serviceCodeId=id(input.serviceCodeId);
+ const date=input.needDate;
+ if(typeof date!=='string'||!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.000)?(?:Z|[+-]\d{2}:\d{2})$/.test(date)||!Number.isFinite(Date.parse(date))||new Date(date.slice(0,19)+'Z').toISOString().slice(0,19)!==date.slice(0,19))throw Error('Need date must be a valid timezone-qualified instant with whole seconds');
+ const status=text(input.status,'need status',100),outcome=text(input.outcome,'need outcome',100);
+ const reasonUnmet=input.reasonUnmet==null?null:text(input.reasonUnmet,'unmet reason',100);
+ if(reasonUnmet&&outcome!=='Not Met')throw Error('Unmet reason requires Not Met outcome');
+ const note=input.note??'';if(typeof note!=='string'||note.length>8000||/[\0\r]/.test(note)||note.includes('[sdk-need:'))throw Error('Invalid need note');
+ const amount=input.amount??null;if(amount!==null&&(!Number.isFinite(amount)||amount<0||Math.abs(amount*100-Math.round(amount*100))>0.000001))throw Error('Need amount must be nonnegative with at most two decimal places');
+ const keyHash=hash(key),marker=`[sdk-need:${keyHash}]`;
+ const values={clientId,providerId,serviceCodeId,needDate:new Date(date).toISOString(),status,outcome,reasonUnmet,note:note?`${note}\n${marker}`:marker,amount};
+ return {key,keyHash,marker,values,intentHash:hash(values)};
+}
+const validateRows=(rows,clientId)=>{
+ if(!Array.isArray(rows)||new Set(rows.map(n=>n.needId)).size!==rows.length)throw Error('Incomplete or duplicate need read');
+ for(const n of rows){id(n.needId);if(n.clientId!==clientId||typeof n.note!=='string'||!Number.isSafeInteger(n.serviceCount)||n.serviceCount<0)throw Error('Invalid need read');}
+ return rows;
+};
+const verify=(row,values)=>{
+ if(Object.entries(values).some(([key,value])=>row[key]!==value))throw new NeedConflictError('stored-fields-changed');
+ if(row.serviceCount!==0)throw new NeedConflictError('service-attached');
+ return row;
+};
+/** A fresh Add Need form, one save, and counted readback. Never creates a service. */
+export function createNeedRecorder({ui,store,tenant=ui?.connection?.tenant}){
+ const tenantScope=ui?.connection?.scope??validateTenant(tenant);
+ if(ui?.connection&&ui.connection.tenant!==validateTenant(tenant))throw Error('Need UI tenant mismatch');
+ if(!ui?.list||!ui?.create||!store?.withLock||!store?.read||!store?.write)throw Error('Need UI and durable store required');
+ return {async record(input){
+  const n=normalizeNeedInput(input),scope=JSON.stringify([tenantScope,'independent-need',n.keyHash]);
+  return store.withLock(scope,async()=>{
+   const entries=await store.read(scope);
+   if(!Array.isArray(entries)||entries.length>1||entries.some(e=>e.version!==1||!['attempted','verified'].includes(e.stage)||typeof e.intentHash!=='string'||e.stage==='verified'&&(!Number.isSafeInteger(e.needId)||e.needId<1)))throw Error('Invalid independent need journal');
+   let entry=entries[0];
+   if(entry&&entry.intentHash!==n.intentHash)throw new NeedConflictError('intent-changed');
+   const locate=async()=>{
+    const rows=validateRows(await ui.list({clientId:n.values.clientId}),n.values.clientId),matches=rows.filter(r=>r.note.includes(n.marker));
+    if(matches.length>1)throw new NeedConflictError('duplicate-marker');
+    if(entry?.needId&&(!matches[0]||matches[0].needId!==entry.needId))throw new NeedConflictError('identity-changed');
+    return matches[0]?verify(matches[0],n.values):null;
+   };
+   let row=await locate();
+   if(row){await store.write(scope,[{version:1,intentHash:n.intentHash,stage:'verified',needId:row.needId}]);return {key:n.key,need:row,outcome:entry?.stage==='attempted'?'reconciled':'already-present'};}
+   if(entry)throw new NeedConflictError('unresolved-save');
+   let failure,attempted=false;
+   try{await ui.create(n.values,async()=>{
+    if(attempted)throw new NeedConflictError('second-save');
+    entry={version:1,intentHash:n.intentHash,stage:'attempted'};
+    await store.write(scope,[entry]);attempted=true;
+   });}catch(error){failure=error;}
+   if(!attempted)throw failure??Error('Need adapter did not journal its save');
+   row=await locate();
+   if(!row)throw failure??new NeedConflictError('unresolved-save');
+   await store.write(scope,[{version:1,intentHash:n.intentHash,stage:'verified',needId:row.needId}]);
+   return {key:n.key,need:row,outcome:failure?'reconciled':'verified'};
+  });
+ }};
+}

package/browser/need-ui.mjs

@@ -0,0 +1,138 @@
+import {pageConnection} from './connection.mjs';
+import {decodeMappedResponse} from './gwt-mapped.mjs';
+import {withPageLock} from './page-lock.mjs';
+const id=n=>{if(!Number.isSafeInteger(n)||n<1)throw Error('Positive integer ID required');return n;};
+
+/** Counted, ordered pages. Never interpret a failed, truncated, or changing read as absence. */
+export async function collectNeedPages(read,key,limit=50000){
+ const rows=[],seen=new Set();let total;
+ for(let offset=0;offset<=limit;offset+=500){
+  const result=await read(offset,500);
+  if(!Number.isSafeInteger(result?.total)||result.total<0||result.total>limit||!Array.isArray(result.rows)||result.rows.length>500||total!==undefined&&result.total!==total)throw Error('Catalog/need count unavailable or changed');
+  total=result.total;
+  for(const row of result.rows){id(row[key]);if(seen.has(row[key]))throw Error('Duplicate catalog/need row');seen.add(row[key]);rows.push(row);}
+  if(rows.length===total)return rows;
+  if(result.rows.length!==500||rows.length>total)throw Error('Incomplete catalog/need read');
+ }
+ throw Error('Catalog/need safety limit exceeded');
+}
+
+/** UI adapter. Catalog reads are shared by services and independent needs. */
+export function createNeedUi({page}){
+ const connection=pageConnection(page),base=connection.moduleBaseUrl;
+ let wire;
+ const guard=()=>{if(new URL(page.url()).origin+new URL(page.url()).pathname!==base+'index.html')throw Error('Configured application page required');};
+ const ready=()=>page.waitForFunction(()=>!document.body.innerText.includes('Processing...')&&!document.body.innerText.includes('Loading...'),null,{timeout:30000});
+ const byId=value=>page.locator(`[id="${value}"]`);
+ const open=async clientId=>{
+  id(clientId);guard();
+  if(await page.locator('[role=dialog]:visible').count()||await page.locator('[id$=".saveAndExit"]:visible,[id="EditNeedView.save"]:visible').count())throw Error('Close unfinished forms before need/catalog workflow');
+  wire=undefined;let pending;
+  const listener=request=>{if(request.url()===base+'service/MetaQueryService'&&request.postData()?.startsWith('7|0|')){
+   const policy=request.postData().split('|')[4];pending=request.allHeaders().then(h=>{wire={policy,headers:Object.fromEntries(['content-type','x-gwt-module-base','x-gwt-permutation'].map(k=>[k,h[k]]))};});
+  }};
+  page.on('request',listener);
+  try{
+   const visibleClient=(await page.locator('body').innerText()).match(/Client - \((\d+)\)/)?.[1];
+   if(visibleClient&&Number(visibleClient)!==clientId){
+    await page.getByRole('tab',{name:'Client Information',exact:true}).click({timeout:30000});await page.getByRole('tab',{name:'Summary',exact:true}).click({timeout:30000});await ready();
+    await page.getByRole('button',{name:'Exit',exact:true}).click({timeout:30000});await page.waitForURL(url=>url.hash==='#clientPointClientMain');await ready();
+   }
+   if(new URL(page.url()).hash!==`#loadClient;clientId=${clientId}`)await page.goto(base+`index.html#loadClient;clientId=${clientId}`);
+   await page.waitForFunction(c=>document.body.innerText.includes(`Client - (${c})`)&&!document.body.innerText.includes('Processing...'),clientId,{timeout:30000});
+   await page.getByRole('tab',{name:'Client Information',exact:true}).click({timeout:30000});await page.getByRole('tab',{name:'Summary',exact:true}).click({timeout:30000});await ready();
+   await page.getByRole('tab',{name:'Service Transactions',exact:true}).click({timeout:30000});await ready();await pending;
+   guard();if(!wire||await byId('formfield-password').isVisible())throw Error('Authenticated need read context unavailable');
+  }finally{page.off('request',listener);}
+ };
+ const mapped=async(query,offset=0,size=500)=>{
+  guard();if(!wire||!query.startsWith('SELECT ')||/[|\\\r\n]/.test(query))throw Error('Invalid need/catalog read');
+  const strings=[base,wire.policy,'com.bowmansystems.sp5.core.client.services.GenericService','getMappedResults','java.lang.String/2004016611','java.util.HashMap/1797211028','I','Z',`${query} LIMIT ${size},${offset}`];
+  const result=await page.evaluate(async w=>{const r=await fetch(w.url,{method:'POST',headers:w.headers,body:w.body,credentials:'same-origin',redirect:'error',signal:AbortSignal.timeout(30000)});return {status:r.status,body:await r.text()};},{url:base+'service/MetaQueryService',headers:wire.headers,body:['7','0',9,...strings,1,2,3,4,5,5,6,7,7,8,9,0,offset,size,1,''].join('|')});
+  if(result.status!==200)throw Error('Need/catalog read failed');return decodeMappedResponse(result.body,offset);
+ };
+ const all=(query,key)=>collectNeedPages((offset,size)=>mapped(query,offset,size),key);
+ const readNeeds=async clientId=>{
+  const rows=await all(`SELECT n.needId AS needId, n.clientId AS clientId, n.providerId AS providerId, n.codeId AS serviceCodeId, n.dateSet AS needDate, n.note AS note, n.amount AS amount, n.status.name AS status, n.outcome.name AS outcome, n.reasonUnmet.name AS reasonUnmet FROM SpNeed AS n WHERE n.active = true AND n.clientId = ${id(clientId)} ORDER BY n.needId`,'needId');
+  const services=await all(`SELECT s.needServiceId AS serviceId, s.needId AS needId FROM SpNeedService AS s WHERE s.active = true AND s.clientId = ${id(clientId)} ORDER BY s.needServiceId`,'serviceId');
+  return rows.map(n=>({...n,note:n.note??'',serviceCount:services.filter(s=>s.needId===n.needId).length}));
+ };
+ const providerRow=()=>page.getByText('Provider',{exact:true}).locator('xpath=ancestor::tr[.//*[@role="button"]][1]');
+ const addForm=async({clientId,providerId})=>{
+  if(providerId!==undefined)id(providerId);await open(clientId);await page.getByRole('button',{name:'Add Need',exact:true}).click({timeout:30000});await byId('ClientAddNeedView.saveAndExit').waitFor({timeout:30000});await ready();
+  if(providerId!==undefined&&!(await providerRow().innerText()).includes(`(${providerId})`)){
+   await providerRow().getByRole('button',{name:'Search',exact:true}).click({timeout:30000});
+   const dialog=page.getByRole('dialog');await dialog.getByText(/Showing \d+-\d+ of \d+/).waitFor({timeout:30000});await ready();
+   await dialog.getByLabel('Provider ID #',{exact:true}).fill(String(providerId),{timeout:30000});await dialog.getByLabel('Provider ID #',{exact:true}).press('Tab',{timeout:30000});
+   await dialog.getByRole('button',{name:'Submit',exact:true}).click({timeout:30000});await ready();
+   await byId(`SpProviderSearchPopup.setProvider-imageLink_${providerId}`).click({timeout:30000});await dialog.waitFor({state:'hidden',timeout:30000});await ready();
+  }
+  if(providerId!==undefined&&!(await providerRow().innerText()).includes(`(${providerId})`))throw Error('Need provider mismatch');
+ };
+ const needSelect=()=>page.locator('select:visible').filter({has:page.locator('option[value="-Select-"]')}).filter({hasNot:page.locator('option[value="Closed"],option[value="Fully Met"],option[value="All Services Full"]')});
+ const options=async label=>page.locator(`select[aria-label="${label}"]`).locator('option').evaluateAll(es=>es.filter(e=>e.value!=='-Select-').map(e=>({value:e.value,label:e.textContent})));
+ const lookup=async()=>{await byId('ClientAddNeedView.lookUp').click({timeout:30000});await byId('SpServiceCodeSearch.codeSets-listbox').waitFor({timeout:30000});await ready();};
+ const cancelLookup=async()=>{await byId('SpServiceCodeSearch.btnExit-button').click({timeout:30000});await byId('SpServiceCodeSearch.btnExit-button').waitFor({state:'hidden',timeout:30000});await ready();};
+ const cancel=async()=>{await byId('ClientAddNeedView.cancel').click({timeout:30000});await byId('ClientAddNeedView.cancel').waitFor({state:'hidden',timeout:30000});await ready();};
+ const readTypes=async filter=>{
+  const types=await all(`SELECT c.serviceCodeId AS serviceCodeId, c.code AS code, c.description AS description, c.serviceCodeTypeId AS codeSetId, c.parentServiceCodeId AS parentServiceCodeId FROM SpServiceCode AS c WHERE c.active = true AND c.assignable = true AND ${filter} AND NOT c.code LIKE 'Y%' AND (c.facet <> 'Modality/Delivery Format' OR c.facet IS NULL) ORDER BY c.serviceCodeId`,'serviceCodeId');
+  for(const t of types){id(t.codeSetId);if(typeof t.code!=='string'||!t.code||typeof t.description!=='string')throw Error('Invalid service code catalog');}
+  return types;
+ };
+ const catalog=async({clientId})=>{
+  await addForm({clientId});await lookup();
+  const codeSets=await byId('SpServiceCodeSearch.codeSets-listbox').locator('option').evaluateAll(es=>es.map(e=>({id:Number(e.value),name:e.textContent})));
+  if(!codeSets.length)throw Error('No accessible service code sets');codeSets.forEach(s=>{id(s.id);if(typeof s.name!=='string'||!s.name)throw Error('Invalid code set');});
+  const types=await readTypes(`c.serviceCodeTypeId IN (${codeSets.map(s=>s.id).join(',')})`);
+  if(types.some(t=>!codeSets.some(s=>s.id===t.codeSetId)))throw Error('Unexpected code set in catalog');
+  await cancelLookup();await cancel();return {codeSets,types};
+ };
+ const quicklist=async context=>{
+  id(context.providerId);await addForm(context);
+  const quickIds=await needSelect().locator('option').evaluateAll(es=>es.filter(e=>e.value!=='-Select-').map(e=>Number(e.value)));quickIds.forEach(id);
+  if(new Set(quickIds).size!==quickIds.length)throw Error('Duplicate provider quicklist entries');
+  const needOptions={statuses:await options('Need Status'),outcomes:await options('Outcome of Need'),unmetReasons:await options('If Need is Not Met, Reason')};
+  const types=quickIds.length?await readTypes(`c.serviceCodeId IN (${quickIds.join(',')})`):[];
+  if(types.length!==quickIds.length||quickIds.some(i=>!types.some(t=>t.serviceCodeId===i)))throw Error('Provider quicklist differs from active assignable types');
+  await cancel();return {providerId:context.providerId,types:quickIds.map(i=>types.find(t=>t.serviceCodeId===i)),needOptions};
+ };
+ const chooseCode=async serviceCodeId=>{
+  id(serviceCodeId);
+  // Cached choices must still be active/assignable at the time of the write.
+  const found=await mapped(`SELECT c.serviceCodeId AS serviceCodeId, c.code AS code, c.serviceCodeTypeId AS codeSetId FROM SpServiceCode AS c WHERE c.active = true AND c.assignable = true AND c.serviceCodeId = ${serviceCodeId}`);
+  if(found.total!==1||found.rows.length!==1||found.rows[0].serviceCodeId!==serviceCodeId)throw Error('Selected service type is no longer active/assignable');
+  if(await needSelect().locator(`option[value="${serviceCodeId}"]`).count()){await needSelect().selectOption(String(serviceCodeId),{timeout:30000});return;}
+  await lookup();
+  const sets=await byId('SpServiceCodeSearch.codeSets-listbox').locator('option').evaluateAll(es=>es.map(e=>Number(e.value)));
+  if(!sets.includes(found.rows[0].codeSetId))throw Error('Selected service type is not accessible');
+  const code=found.rows[0];await byId('SpServiceCodeSearch.codeSets-listbox').selectOption(String(code.codeSetId),{timeout:30000});
+  await byId('SpServiceCodeSearch.searchTerm-listbox').selectOption('Code',{timeout:30000});await byId('SpServiceCodeSearch.searchText-textbox').fill(code.code,{timeout:30000});
+  await byId('SpServiceCodeSearch.searchBtn-button').click({timeout:30000});await ready();
+  await byId(`SpServiceCodeSearch.selectLink-code-${serviceCodeId}`).click({timeout:30000});await byId('SpServiceCodeSearch.btnSubmit-button').click({timeout:30000});await byId('SpServiceCodeSearch.btnSubmit-button').waitFor({state:'hidden',timeout:30000});await ready();
+  if(await needSelect().inputValue()!==String(serviceCodeId))throw Error('Need code selection mismatch');
+ };
+ const fillDate=async instant=>{
+  const parts=await page.evaluate(value=>{const d=new Date(value),copy=new Date(d.getFullYear(),d.getMonth(),d.getDate(),d.getHours(),d.getMinutes(),d.getSeconds());if(copy.getTime()!==d.getTime())throw Error('Ambiguous local need time');return {Month:String(d.getMonth()+1),Day:String(d.getDate()),Year:String(d.getFullYear()),Hour:String(d.getHours()%12||12),Minute:String(d.getMinutes()).padStart(2,'0'),Second:String(d.getSeconds()).padStart(2,'0'),'AM/PM':d.getHours()<12?'AM':'PM'};},instant);
+  for(const [part,value]of Object.entries(parts)){const field=page.getByLabel('Date of Need '+part,{exact:true});if(['Month','Day','Year'].includes(part)){await field.fill(value,{timeout:30000});await field.press('Tab',{timeout:30000});}else await field.selectOption(value,{timeout:30000});}
+ };
+ return {connection,
+  list:({clientId})=>withPageLock(page,async()=>{await open(clientId);return readNeeds(clientId);}),
+  listServiceTypes:context=>withPageLock(page,()=>catalog(context)),
+  listServiceQuicklist:context=>withPageLock(page,()=>quicklist(context)),
+  create:(values,beforeSave)=>withPageLock(page,async()=>{
+   if(typeof beforeSave!=='function')throw Error('Durable beforeSave hook required');
+   await addForm(values);await chooseCode(values.serviceCodeId);
+   // A single independent need, never implicitly include household checkboxes.
+   const checked=page.locator('input[type=checkbox]:visible:checked');
+   if(await checked.count())throw Error('Unexpected checked household members; refusing a group need');
+   await fillDate(values.needDate);await page.locator('select[aria-label="Need Status"]').selectOption({label:values.status},{timeout:30000});
+   await page.locator('select[aria-label="Outcome of Need"]').selectOption({label:values.outcome},{timeout:30000});
+   if(values.reasonUnmet)await page.locator('select[aria-label="If Need is Not Met, Reason"]').selectOption({label:values.reasonUnmet},{timeout:30000});
+   await page.locator('input[aria-label="Amount if Financial"]').fill(values.amount===null?'':String(values.amount),{timeout:30000});
+   await page.locator('textarea[aria-label="Notes"]').fill(values.note,{timeout:30000});
+   if(!(await providerRow().innerText()).includes(`(${values.providerId})`)||await needSelect().inputValue()!==String(values.serviceCodeId))throw Error('Need context changed before save');
+   await beforeSave();await byId('ClientAddNeedView.saveAndExit').click({timeout:30000});
+   await byId('ClientAddNeedView.saveAndExit').waitFor({state:'hidden',timeout:30000});await ready();
+  }),
+ };
+}

package/browser/page-lock.mjs

@@ -0,0 +1,11 @@
+import {sessionAuthentication} from './session-authentication.mjs';
+const locks=new WeakMap();
+export async function withPageLock(page,work,{authentication=true}={}){
+  const previous=locks.get(page)??Promise.resolve();let release;
+  const current=new Promise(resolve=>{release=resolve;});locks.set(page,current);await previous;
+  try{
+    const auth=authentication?sessionAuthentication(page):undefined;
+    await auth?.before();
+    try{return await work();}catch(error){if(auth)return await auth.afterFailure(error);throw error;}
+  }finally{release();if(locks.get(page)===current)locks.delete(page);}
+}

package/browser/password-recovery.mjs

@@ -0,0 +1,49 @@
+// Internal UI steps. The login orchestrator owns the account lock and write journal.
+export async function waitForLogin(page,timeoutMs){
+ await page.waitForFunction(()=>{
+  const visible=e=>e&&e.getBoundingClientRect().width>0;
+  const expired=document.body.innerText.includes('Password has expired!')&&visible(document.getElementById('formfield-password2'))&&visible(document.getElementById('formfield-password'));
+  const dashboard=location.hash==='#mainPage'&&!visible(document.getElementById('formfield-password'))&&document.body.innerText.includes('Home Page Dashboard')&&!document.body.innerText.includes('Processing...')&&!document.body.innerText.includes('Loading Modules');
+  return expired||dashboard;
+ },null,{timeout:timeoutMs});
+ return await page.locator('[id="formfield-password2"]').isVisible()?'expired':'dashboard';
+}
+export async function submitExpiredPassword(page,password,beforeSubmit,timeoutMs){
+ if(await waitForLogin(page,timeoutMs)!=='expired')throw Error('Expected expired-password form');
+ await page.locator('[id="formfield-password2"]').fill(password);
+ await page.locator('[id="formfield-password"]').fill(password);
+ await beforeSubmit();
+ await page.locator('[id="LoginView.fbtn_submit"]').click();
+ // Waiting for a dashboard prevents interpreting the unchanged reset form as success.
+ await page.waitForFunction(()=>location.hash==='#mainPage'&&!document.body.innerText.includes('Password has expired!'),null,{timeout:timeoutMs});
+ if(await waitForLogin(page,timeoutMs)!=='dashboard')throw Error('Temporary password was not confirmed');
+}
+export async function restoreOriginalPassword(page,temporaryPassword,originalPassword,beforeSubmit,timeoutMs){
+ await page.locator('[title^="Edit User Profile for "]').click();
+ await page.locator('[id="UserProfilePopup.changePassword-button"]').click();
+ const save=page.locator('[id="UserProfileChangePasswordPopup.save-button"]');
+ await save.waitFor({state:'visible',timeout:timeoutMs});
+ const dialog=save.locator('xpath=ancestor::*[@role="dialog"][1]');
+ for(const [name,value]of [['Current Password',temporaryPassword],['New Password',originalPassword],['Re-enter New Password',originalPassword]]){
+  const field=dialog.getByLabel(name,{exact:true});
+  if(await field.count()!==1||await field.getAttribute('maxlength')!=='50')throw Error('Password settings form changed');
+  await field.fill(value);
+ }
+ await beforeSubmit();
+ await save.click();
+ await save.waitFor({state:'hidden',timeout:timeoutMs});
+ // The login orchestrator verifies the original password in a fresh context.
+}
+
+/** A separate read-only page distinguishes stale-session HTTP 500s from real server errors. */
+export async function probeAuthentication(context,moduleUrl,timeoutMs){
+ const page=await context.newPage();
+ try{
+  await page.goto(moduleUrl+'index.html',{waitUntil:'domcontentloaded',timeout:timeoutMs});
+  await page.waitForFunction(()=>{
+   const password=document.getElementById('formfield-password');
+   return password&&password.getBoundingClientRect().width>0||location.hash==='#mainPage'&&document.body.innerText.includes('Home Page Dashboard');
+  },null,{timeout:timeoutMs});
+  return await page.locator('[id="formfield-password"]').isVisible();
+ }finally{await page.close();}
+}

package/browser/playwright-session.mjs

@@ -0,0 +1,196 @@
+import {createHash,randomUUID} from 'node:crypto';
+import {GwtEnrollmentHelpers} from '../dist/esm/index.js';
+import {decodeMappedResponse} from './gwt-mapped.mjs';
+
+import {withPageLock} from './page-lock.mjs';
+import {sessionGeneration} from './session-authentication.mjs';
+import {resolveUiConnection} from './connection.mjs';
+const rpcInterface='com.bowmansystems.sp5.core.client.services.GenericService';
+const id=n=>{if(!Number.isSafeInteger(n)||n<=0)throw Error('Positive integer ID required');return n;};
+const literal=value=>{if(Number.isSafeInteger(value))return String(value);if(typeof value==='string'&&/^[a-zA-Z0-9_-]+$/.test(value))return `'${value}'`;throw Error('Unsupported group identifier');};
+const digest=value=>createHash('sha256').update(value).digest('hex');
+const control=(page,value)=>page.locator(`[id="${value}"]:visible`);
+
+/** Own the supplied page exclusively. Keep the browser context alive; managed sessions reauthenticate only between operations.
+ * UI selectors and wire signatures are experimental and fail closed when the application changes. */
+export function createPlaywrightEnrollmentHelpers({page,store,tenant,moduleBaseUrl}) {
+  const session=createPlaywrightGwtSession({page,tenant,moduleBaseUrl});
+  // The durable store serializes enrollment writers across processes. This lock additionally
+  // serializes the ENTIRE operation across all helper instances sharing one browser page.
+  const lockedStore={read:scope=>store.read(scope),write:(scope,records)=>store.write(scope,records),withLock:(scope,work)=>withPageLock(page,()=>store.withLock(scope,work))};
+  return new GwtEnrollmentHelpers({tenant,moduleBaseUrl,session,store:lockedStore,maxPayloadAgeMs:60000});
+}
+
+/** Low-level adapter. Prefer the factory above, which also locks the page. */
+export function createPlaywrightGwtSession({page,tenant,moduleBaseUrl}) {
+  const base=new URL(moduleBaseUrl);
+  if(base.protocol!=='https:'||base.username||base.password||base.search||base.hash||!/^\w[\w-]*$/.test(tenant)||base.pathname!==`/${tenant}/com.bowmansystems.sp5.core.ServicePoint/`)throw Error('Invalid GWT module URL');
+  page.setDefaultTimeout(30000);
+  const endpoint=moduleBaseUrl+'service/ClientService';
+  let sessionId=randomUUID(),generation=sessionGeneration(page),wire,pending;
+  const checkGeneration=()=>{
+    const current=sessionGeneration(page);
+    if(current!==generation){generation=current;sessionId=randomUUID();wire=undefined;pending=undefined;}
+  };
+  const ready=()=>page.waitForFunction(()=>!document.body.innerText.includes('Processing...')&&!document.body.innerText.includes('Loading...'),null,{timeout:30000});
+  const guard=async()=>{
+    checkGeneration();
+    const u=new URL(page.url());if(u.origin!==base.origin||u.pathname!==base.pathname+'index.html'||await control(page,'formfield-password').count())throw Error('Authenticated page unavailable');
+  };
+  const closeDialogs=async()=>{
+    for(let i=0;i<12;i++){
+      let closed=false;
+      for(const name of ['AddAdditionalHouseholdMembersPopup.cancelBtn','ModifyReviewPopup.cancel-button','EntryDataPopup.cancel-button','ExitDataPopup.cancel-button','EntryExitReviewClientCountPopup.btnExit','EntryExitClientCountPopup.btnExit','EntryExitAssessment.btnExit-button','EntryExitReviewListPopup.btnExit']){
+        const c=control(page,name);if(await c.count()){await c.last().click();await ready();closed=true;break;}
+      }
+      if(!closed)return;
+    }
+    throw Error('Could not close enrollment dialogs');
+  };
+  const openTarget=async(target)=>{
+    id(target.clientId);id(target.enrollmentId);await guard();await closeDialogs();
+    const clientHeading=page.getByText(new RegExp(`^Client - \\(${target.clientId}\\)`));
+    if(!await clientHeading.isVisible()){
+      const switcher=page.locator('select:visible').filter({has:page.locator(`option[value="${target.clientId}"]`)});
+      if(await switcher.count()===1&&await control(page,'ClientMainView.householdSubmitButton').isVisible()){
+        await switcher.selectOption(String(target.clientId));await control(page,'ClientMainView.householdSubmitButton').click();
+      }else{
+        // A hash alone is not proof that GWT switched the displayed client.
+        if(new URL(page.url()).hash===`#loadClient;clientId=${target.clientId}`)throw Error('Client navigation did not load the requested client');
+        await page.goto(moduleBaseUrl+`index.html#loadClient;clientId=${target.clientId}`);
+      }
+      await clientHeading.waitFor();await ready();
+    }
+    await page.getByRole('tab',{name:'Summary',exact:true}).click();await ready();
+    await page.getByRole('tab',{name:'Entry / Exit',exact:true}).click();await ready();
+    const edit=control(page,`ClientEntryExitTab.editEntry-imageLink_${target.enrollmentId}`);
+    await edit.waitFor();
+    const response=page.waitForResponse(r=>r.url()===endpoint&&r.request().postData()?.includes('|getEntryExit|')&&r.request().postData()?.endsWith(`|${target.enrollmentId}|`));
+    await edit.click();const r=await response,body=await r.text();
+    if(r.status()!==200||!body.startsWith('//OK['))throw Error('Entry read failed');
+    const request=r.request(),tokens=request.postData().split('|'),headers=await request.allHeaders();
+    wire={policy:tokens[4],headers:Object.fromEntries(['content-type','x-gwt-module-base','x-gwt-permutation'].map(k=>[k,headers[k]]))};
+    await control(page,'EntryDataPopup.cancel-button').waitFor();await ready();
+    if(!(await page.locator('body').innerText()).includes(`Edit Project Start Data - (${target.clientId})`))throw Error('Entry client mismatch');
+    return body;
+  };
+  const post=async request=>{
+    await guard();
+    return page.evaluate(async({url,headers,body})=>{
+      const controller=new AbortController(),timer=setTimeout(()=>controller.abort(),30000);
+      try{const r=await fetch(url,{method:'POST',headers,body,credentials:'same-origin',redirect:'error',signal:controller.signal});return {status:r.status,body:await r.text()};}finally{clearTimeout(timer);}
+    },request);
+  };
+  const mapped=async query=>{
+    if(!wire||!/^SELECT /.test(query)||/[|\\\r\n]/.test(query))throw Error('Invalid mapped read');
+    const strings=[moduleBaseUrl,wire.policy,rpcInterface,'getMappedResults','java.lang.String/2004016611','java.util.HashMap/1797211028','I','Z',query+' LIMIT 1001,0'];
+    const body=['7','0',strings.length,...strings,1,2,3,4,5,5,6,7,7,8,9,0,0,1001,1,''].join('|');
+    const response=await post({url:moduleBaseUrl+'service/MetaQueryService',headers:wire.headers,body});if(response.status!==200)throw Error('Mapped read failed');
+    const data=decodeMappedResponse(response.body);if(data.total!==data.rows.length||data.total>1000)throw Error('Incomplete enrollment list');return data.rows;
+  };
+  const householdIds=async target=>{
+    const link=page.getByText('Include Additional Household Members',{exact:true});
+    if(await link.isVisible()){
+      await link.click();await control(page,'AddAdditionalHouseholdMembersPopup.saveBtn').waitFor();await ready();
+    }
+    const ids=await page.locator('[id^="HouseholdsCheckboxTree.householdCheckbox."]:visible').evaluateAll(es=>es.map(e=>Number(e.id.match(/\.client-(\d+)$/)?.[1])));
+    if(ids.some(n=>!Number.isSafeInteger(n)||n<=0))throw Error('Invalid household tree');
+    await closeDialogs();return [...new Set([target.clientId,...ids])].sort((a,b)=>a-b);
+  };
+  const readEnrollment=async target=>{
+    const model=await openTarget(target),householdClientIds=await householdIds(target);
+    const entries=await mapped(`SELECT e.entryExitId AS enrollmentId, e.clientId AS clientId, e.entryDate AS projectStartDate, e.groupId AS groupId, e.providerId AS providerId, e.typeEntryExit.name AS enrollmentType FROM SpEntryExit AS e WHERE e.active = TRUE AND e.entryExitId = ${id(target.enrollmentId)} AND e.clientId = ${id(target.clientId)}`);
+    if(entries.length!==1)throw Error('Enrollment missing');const entry=entries[0];
+    if(entry.enrollmentId!==target.enrollmentId||entry.clientId!==target.clientId||!Number.isSafeInteger(entry.providerId)||entry.providerId<=0||typeof entry.enrollmentType!=='string'||!entry.enrollmentType.trim())throw Error('Enrollment context incomplete');
+    const members=entry.groupId===null?[{clientId:target.clientId,enrollmentId:target.enrollmentId}]:await mapped(`SELECT e.entryExitId AS enrollmentId, e.clientId AS clientId FROM SpEntryExit AS e WHERE e.active = TRUE AND e.client.active = TRUE AND e.groupId = ${literal(entry.groupId)}`);
+    members.sort((a,b)=>a.clientId-b.clientId);
+    const exitRows=await mapped(`SELECT e.entryExitId AS enrollmentId, e.clientId AS clientId, e.exitDate AS projectExitDate, e.destinationValue.name AS destination, e.destinationValue.code AS destinationCode, e.reasonLeavingValue.name AS reasonForLeaving, e.reasonLeavingValue.code AS reasonForLeavingCode, e.exitSubgroupId AS exitSubgroupId FROM SpEntryExit AS e WHERE e.active = TRUE AND e.client.active = TRUE AND ${entry.groupId===null?`e.entryExitId = ${id(target.enrollmentId)}`:`e.groupId = ${literal(entry.groupId)}`}`);
+    if(exitRows.length!==members.length||new Set(exitRows.map(r=>r.enrollmentId)).size!==exitRows.length||exitRows.some(r=>!members.some(m=>m.clientId===r.clientId&&m.enrollmentId===r.enrollmentId)))throw Error('Enrollment exit list incomplete');
+    const exitGroups=new Map(),exits=[];
+    for(const row of exitRows){
+      if(row.projectExitDate!==null&&(typeof row.projectExitDate!=='string'||!Number.isFinite(Date.parse(row.projectExitDate))))throw Error('Enrollment exit date invalid');
+      for(const field of ['destination','destinationCode','reasonForLeaving','reasonForLeavingCode'])if(row[field]!==null&&(typeof row[field]!=='string'||!row[field]))throw Error('Enrollment exit value invalid');
+      if(row.exitSubgroupId!==null&&(typeof row.exitSubgroupId!=='string'||!row.exitSubgroupId))throw Error('Enrollment exit subgroup invalid');
+      let group=[{clientId:row.clientId,enrollmentId:row.enrollmentId}];
+      if(row.exitSubgroupId!==null){
+        if(!exitGroups.has(row.exitSubgroupId))exitGroups.set(row.exitSubgroupId,await mapped(`SELECT e.clientId AS clientId, e.entryExitId AS enrollmentId FROM SpEntryExit AS e WHERE e.active = TRUE AND e.client.active = TRUE AND e.exitSubgroupId = ${literal(row.exitSubgroupId)}`));
+        group=exitGroups.get(row.exitSubgroupId);
+        if(!group.some(m=>m.clientId===row.clientId&&m.enrollmentId===row.enrollmentId)||new Set(group.map(m=>m.clientId)).size!==group.length||new Set(group.map(m=>m.enrollmentId)).size!==group.length)throw Error('Enrollment exit subgroup incomplete');
+      }
+      exits.push({...row,clientIds:group.map(m=>id(m.clientId)).sort((a,b)=>a-b),enrollmentIds:group.map(m=>id(m.enrollmentId)).sort((a,b)=>a-b)});
+    }
+    exits.sort((a,b)=>a.clientId-b.clientId);
+    const rows=await mapped(`SELECT r.entryExitReviewId AS reviewId, r.subgroupId AS subgroupId, r.reviewDate AS reviewDate, r.reviewType.name AS type FROM SpEntryExitReview AS r WHERE r.active = TRUE AND r.entryExitId = ${id(target.enrollmentId)} AND r.pointInTimeType.code = 'EEPOINTINTIME_INTERIM'`);
+    const reviews=[];
+    for(const row of rows){
+      const clients=row.subgroupId===null?[{clientId:target.clientId}]:await mapped(`SELECT r.entryExit.clientId AS clientId FROM SpEntryExitReview AS r WHERE r.active = TRUE AND r.entryExit.active = TRUE AND r.entryExit.client.active = TRUE AND r.subgroupId = ${literal(row.subgroupId)}`);
+      reviews.push({reviewId:row.reviewId,type:row.type,reviewDate:row.reviewDate,clientIds:clients.map(c=>c.clientId).sort((a,b)=>a-b)});
+    }
+    reviews.sort((a,b)=>a.reviewId-b.reviewId);
+    const data={source:'gwt-rpc',tenant,sessionId,...target,projectStartDate:entry.projectStartDate,providerId:entry.providerId,enrollmentType:entry.enrollmentType,householdClientIds,members,exits,reviews};
+    return {...data,revision:digest(model+JSON.stringify({...data,sessionId:undefined}))};
+  };
+  const chooseMembers=async(desired,implicitClientId,dialogButton)=>{
+    const surface=control(page,dialogButton).locator('xpath=ancestor::*[@role="dialog"][1]');
+    if(await surface.count()!==1)throw Error('Active household dialog unavailable');
+    const boxes=surface.locator('[id^="HouseholdsCheckboxTree.householdCheckbox."]:visible input');
+    // Clients without a household have no checkbox tree. Their review dialog
+    // binds the sole client implicitly and emits the single-client RPC.
+    if(await boxes.count()===0&&implicitClientId!==undefined){
+      if(desired.length!==1||desired[0]!==implicitClientId||!(await page.locator('body').innerText()).includes(`Add Interim Review - (${implicitClientId})`))throw Error('Implicit review client mismatch');
+      return true;
+    }
+    for(let i=0;i<await boxes.count();i++){
+      const box=boxes.nth(i),clientId=await box.evaluate(e=>Number(e.parentElement.id.match(/\.client-(\d+)$/)?.[1]));
+      if(await box.isEnabled())await box.setChecked(desired.includes(clientId));
+      if((await box.isChecked())!==desired.includes(clientId))throw Error('Unexpected included household member');
+    }
+    const selected=await surface.locator('[id^="HouseholdsCheckboxTree.householdCheckbox."]:visible input:checked').evaluateAll(es=>es.map(e=>Number(e.parentElement.id.match(/\.client-(\d+)$/)?.[1])).sort((a,b)=>a-b));
+    if(JSON.stringify(selected)!==JSON.stringify([...desired].sort((a,b)=>a-b)))throw Error('Household selection incomplete');
+    return false;
+  };
+  const dateFields=async label=>{
+    const fields={};for(const part of ['Month','Day','Year','Hour','Minute','Second','AM/PM'])fields[part]=await page.getByLabel(`${label} ${part}`,{exact:true}).inputValue();return fields;
+  };
+  const prepare=async(intent,snapshot)=>{
+    checkGeneration();if(snapshot.sessionId!==sessionId)throw Error('Session mismatch');pending=undefined;
+    await openTarget(intent);const entryFields=await dateFields('Project Start Date');
+    let save,singleClientReview=false;
+    if(intent.kind==='add-household-members'){
+      await page.getByText('Include Additional Household Members',{exact:true}).click();await control(page,'AddAdditionalHouseholdMembersPopup.saveBtn').waitFor();await ready();
+      await chooseMembers([...new Set([...snapshot.members.map(m=>m.clientId),...intent.memberClientIds])],undefined,'AddAdditionalHouseholdMembersPopup.saveBtn');
+      await control(page,'AddAdditionalHouseholdMembersPopup.saveBtn').click();
+      // Continue starts a second asynchronous household-tree render. A visible Save button is insufficient.
+      await page.getByRole('checkbox',{name:new RegExp(`^\\(${intent.memberClientIds[0]}\\)`)}).waitFor();await ready();
+      // Existing members remain linked when unchecked here; these boxes choose
+      // whose entry data is updated. Never copy the anchor date to other members.
+      await chooseMembers([...new Set([intent.clientId,...intent.memberClientIds])],undefined,'EntryDataPopup.saveAndContinue-button');
+      if(JSON.stringify(entryFields)!==JSON.stringify(await dateFields('Project Start Date')))throw Error('Entry date changed');
+      save=control(page,'EntryDataPopup.saveAndContinue-button');
+    }else{
+      await closeDialogs();const row=control(page,`ClientEntryExitTab.editEntry-imageLink_${intent.enrollmentId}`).locator('xpath=ancestor::tr');
+      await row.locator('[title^="Interim Reviews:"]').click();await control(page,'EntryExitReviewListPopup.addReviewButton').waitFor();await ready();await control(page,'EntryExitReviewListPopup.addReviewButton').click();await control(page,'ModifyReviewPopup.saveAndContinue-button').waitFor();await ready();
+      const soleClient=snapshot.members.length===1&&snapshot.members[0].clientId===intent.clientId&&snapshot.householdClientIds.length===1&&snapshot.householdClientIds[0]===intent.clientId;
+      singleClientReview=await chooseMembers(intent.clientIds,soleClient?intent.clientId:undefined,'ModifyReviewPopup.saveAndContinue-button');await page.getByLabel('Interim Review Type',{exact:true}).selectOption({label:'Update'});
+      const fields=await page.evaluate(value=>{const d=new Date(value);if(d.getMilliseconds())throw Error('UI supports whole seconds only');const local=new Date(d.getFullYear(),d.getMonth(),d.getDate(),d.getHours(),d.getMinutes(),d.getSeconds());if(+local!==+d)throw Error('Ambiguous local review time');return {Month:String(d.getMonth()+1).padStart(2,'0'),Day:String(d.getDate()).padStart(2,'0'),Year:String(d.getFullYear()),Hour:String(d.getHours()%12||12),Minute:String(d.getMinutes()).padStart(2,'0'),Second:String(d.getSeconds()).padStart(2,'0'),'AM/PM':d.getHours()<12?'AM':'PM'};},intent.reviewDate);
+      for(const [part,value]of Object.entries(fields)){const c=page.getByLabel(`Review Date ${part}`,{exact:true});if(['Month','Day','Year'].includes(part))await c.fill(value);else await c.selectOption({label:value});}
+      if(JSON.stringify(fields)!==JSON.stringify(await dateFields('Review Date')))throw Error('Review date mismatch');
+      save=control(page,'ModifyReviewPopup.saveAndContinue-button');
+    }
+    const expected=intent.kind==='add-household-members'?'updateEntryExitWithHouseholdMembers':singleClientReview?'createEntryExitReview':'createEntryExitReviewWithHouseholdMembers';
+    let resolveCapture;const captured=new Promise(resolve=>{resolveCapture=resolve;});
+    const handler=async route=>{
+      const r=route.request(),body=r.postData()??'';
+      // Block EVERY request while pressing Save. No unexpected RPC can leak through the capture step.
+      await route.abort();const tokens=body.split('|');
+      if(r.url()===endpoint&&tokens[6]===expected){const h=await r.allHeaders();resolveCapture({intent:structuredClone(intent),sessionId,revision:snapshot.revision,capturedAt:Date.now(),url:endpoint,body,headers:Object.fromEntries(['content-type','x-gwt-module-base','x-gwt-permutation'].map(k=>[k,h[k]]))});}
+      else resolveCapture(null);
+    };
+    await page.route('**/service/**',handler);let timer;
+    try{await save.click();const result=await Promise.race([captured,new Promise(resolve=>{timer=setTimeout(()=>resolve(null),15000);})]);if(!result)throw Error('Expected mutation was not captured');pending=digest(JSON.stringify({url:result.url,headers:result.headers,body:result.body}));return result;}
+    finally{clearTimeout(timer);await page.unroute('**/service/**',handler);await ready();await closeDialogs();}
+  };
+  return {connection:resolveUiConnection({tenant,moduleBaseUrl}),readEnrollment,prepare,async send(request){
+    checkGeneration();const fingerprint=digest(JSON.stringify(request));if(!pending||fingerprint!==pending)throw Error('Only the newly prepared request can be sent once');pending=undefined;return post(request);
+  }};
+}

package/browser/program-discovery.d.mts

@@ -0,0 +1,22 @@
+import type {Page} from 'playwright-core';
+export interface AssessmentCatalogItem { assessmentId:number; name:string; code:string }
+export interface ProviderAssessmentItem extends AssessmentCatalogItem { assignedToAssessmentTab:boolean }
+export interface AssessmentDisplayDefault {
+  location:string;
+  label:string;
+  allowMultiple:boolean|null;
+  assessmentName:string|null;
+  /** Unresolved includes absent/ambiguous names in the active published provider catalog. */
+  resolution:'unset'|'resolved'|'unresolved';
+  assessment:ProviderAssessmentItem|null;
+}
+export interface ProgramDiscovery {
+ readonly connection?:import("./connection.mjs").UiConnection;
+  listAssessments():Promise<{source:'admin-catalog';retrievedAt:string;assessments:AssessmentCatalogItem[]}>;
+  getProviderAssessments(input:{providerId:number}):Promise<{
+    source:'provider-display-settings';providerId:number;retrievedAt:string;
+    assessments:ProviderAssessmentItem[];defaults:AssessmentDisplayDefault[];
+  }>;
+}
+/** Requires an authenticated, dedicated application page and administrative read access. No Save is clicked. */
+export function createProgramDiscovery(input:{page:Page}):ProgramDiscovery;