gate-evm-tools 1.2.0 → 1.2.2

package/runtime/delivery/configuration-definition.ts

@@ -30,6 +30,17 @@ function data(n:ts.Expression):any {
   if(ts.isStringLiteral(n))return n.text;
   if(ts.isNumericLiteral(n)){const v=Number(n.text);if(!Number.isSafeInteger(v))return fail();return v;}
   if(n.kind===ts.SyntaxKind.TrueKeyword)return true;if(n.kind===ts.SyntaxKind.FalseKeyword)return false;
+  if(ts.isPrefixUnaryExpression(n)&&[ts.SyntaxKind.PlusToken,ts.SyntaxKind.MinusToken].includes(n.operator)){
+    const operand=data(n.operand);if(typeof operand!=='number')return fail();return n.operator===ts.SyntaxKind.MinusToken?-operand:operand;
+  }
+  if(ts.isBinaryExpression(n)){
+    const left=data(n.left),right=data(n.right);if(typeof left!=='number'||typeof right!=='number')return fail();
+    const operations:Record<number,()=>number>={
+      [ts.SyntaxKind.PlusToken]:()=>left+right,[ts.SyntaxKind.MinusToken]:()=>left-right,
+      [ts.SyntaxKind.AsteriskToken]:()=>left*right,[ts.SyntaxKind.SlashToken]:()=>left/right,[ts.SyntaxKind.PercentToken]:()=>left%right,
+    };
+    const operation=operations[n.operatorToken.kind];if(!operation)return fail();const value=operation();if(!Number.isSafeInteger(value))return fail();return value;
+  }
   if(ts.isArrayLiteralExpression(n))return n.elements.map(e=>data(e as ts.Expression));
   return Object.fromEntries([...fields(n)].map(([k,v])=>[k,data(v)]));
 }
@@ -88,13 +99,18 @@ function accounts(n:ts.Expression,local:boolean,env:NodeJS.ProcessEnv,credential
 }
 const common=['chainId','from','gas','gasPrice','gasMultiplier'];
 const localFields=[...common,'initialBaseFeePerGas','hardfork','mining','accounts','blockGasLimit','minGasPrice','throwOnTransactionFailures','throwOnCallFailures','allowUnlimitedContractSize','allowBlocksWithSameTimestamp','initialDate','loggingEnabled','forking','coinbase','chains','enableTransientStorage','enableRip7212'];
-const httpFields=[...common,'url','timeout','httpHeaders','accounts'];
-function network(n:ts.Expression,local:boolean,env:NodeJS.ProcessEnv,helper:boolean,credentialResolver:boolean):{value:Data;definition:Data} {
+const httpFields=[...common,'url','timeout','httpHeaders','accounts','zksync','ethNetwork'];
+function network(n:ts.Expression,local:boolean,env:NodeJS.ProcessEnv,helper:boolean,credentialResolver:boolean,aliases:Map<string,ts.Expression>,usedAliases:Set<string>):{value:Data;definition:Data} {
   const value:Data={},definition:Data={};
   for(const [key,node] of fields(n)){
     if(!(local?localFields:httpFields).includes(key))return fail();
     if(key==='url'){const s=networkUrl(node,env,helper);value[key]=s.value;definition[key]=s.definition;}
-    else if(key==='accounts'){const a=accounts(node,local,env,credentialResolver);value[key]=a.value;definition[key]=a.definition;}
+    else if(key==='accounts'){
+      let initializer=node;
+      if(ts.isIdentifier(node)){if(!aliases.has(node.text))return fail();usedAliases.add(node.text);initializer=aliases.get(node.text)!;}
+      const a=accounts(initializer,local,env,credentialResolver);value[key]=a.value;definition[key]=a.definition;
+    }
+    else if(key==='ethNetwork'){const s=secret(node,env);value[key]=s.value;definition[key]=s.definition;}
     else if(key==='httpHeaders'){const h=headers(node,env);value[key]=h.value;definition[key]=h.definition;}
     else if(key==='forking'){
       const v:Data={},d:Data={};for(const [k,x] of fields(node)){
@@ -113,7 +129,8 @@ function network(n:ts.Expression,local:boolean,env:NodeJS.ProcessEnv,helper:bool
   if('hardfork'in value&&!['chainstart','homestead','dao','tangerineWhistle','spuriousDragon','byzantium','constantinople','petersburg','istanbul','muirGlacier','berlin','london','arrowGlacier','grayGlacier','merge','shanghai','cancun','prague'].includes(value.hardfork))return fail();
   if(value.mining){keys(value.mining,['auto','interval','mempool']);if('auto'in value.mining&&typeof value.mining.auto!=='boolean')return fail();if('interval'in value.mining){const i=value.mining.interval;if(!(Number.isSafeInteger(i)&&i>=0)&&!(Array.isArray(i)&&i.length===2&&i.every(x=>Number.isSafeInteger(x)&&x>=0)&&i[0]<=i[1]))return fail();}if(value.mining.mempool){keys(value.mining.mempool,['order']);if(!['priority','fifo'].includes(value.mining.mempool.order))return fail();}}
   if(value.chains)for(const [id,c] of Object.entries(value.chains)){if(!/^[1-9]\d*$/.test(id)||!Number.isSafeInteger(Number(id)))return fail();keys(c as Data,['hardforkHistory']);for(const [fork,block] of Object.entries((c as Data).hardforkHistory??{})){if(typeof fork!=='string'||!Number.isSafeInteger(block)||(block as number)<0)return fail();}}
-  if(!local&&(!('url'in value)||!Number.isSafeInteger(value.chainId)||value.chainId<=0))return fail();
+  if('zksync'in value&&typeof value.zksync!=='boolean')return fail();
+  if(!local&&!('url'in value))return fail();
   return {value,definition};
 }
 function compiler(config:any):void {
@@ -121,6 +138,47 @@ function compiler(config:any):void {
   if('version'in config){keys(config,['version','settings']);compiler(config.version);if(config.settings){keys(config.settings,['optimizer','evmVersion','viaIR','outputSelection','metadata','libraries','remappings','debug','stopAfter']);if(config.settings.optimizer){keys(config.settings.optimizer,['enabled','runs','details']);if(config.settings.optimizer.details)keys(config.settings.optimizer.details,['peephole','inliner','jumpdestRemover','orderLiterals','deduplicate','cse','constantOptimizer','yul','yulDetails']);}if(config.settings.metadata)keys(config.settings.metadata,['appendCBOR','useLiteralContent','bytecodeHash']);if(config.settings.debug)keys(config.settings.debug,['revertStrings','debugInfo']);}return;}
   keys(config,['compilers','overrides']);if(!Array.isArray(config.compilers)||!config.compilers.length)fail();config.compilers.forEach(compiler);if(config.overrides)Object.values(config.overrides).forEach(compiler);
 }
+const pluginsSupported=new Set(['gate-evm-tools/delivery-hardhat','@nomicfoundation/hardhat-ethers',
+  '@nomicfoundation/hardhat-chai-matchers','@openzeppelin/hardhat-upgrades','@OpenZeppelin/hardhat-upgrades',
+  '@nomicfoundation/hardhat-foundry','@nomicfoundation/hardhat-toolbox','@nomicfoundation/hardhat-verify',
+  '@matterlabs/hardhat-zksync-solc','@matterlabs/hardhat-zksync-deploy',
+  'hardhat-abi-exporter','hardhat-contract-sizer','hardhat-gas-reporter','@typechain/hardhat']);
+const pluginFields:Record<string,string[]>={
+  mocha:['timeout','bail','allowUncaught','forbidOnly','forbidPending','fullTrace','retries','slow','parallel','grep','invert'],
+  contractSizer:['alphaSort','disambiguatePaths','runOnCompile','strict','only','except','unit','precision'],
+  abiExporter:['path','runOnCompile','clear','flat','pretty','except','only','format','spacing'],
+  typechain:['outDir','target','alwaysGenerateOverloads','dontOverrideCompile','externalArtifacts','discriminateTypes','tsNocheck'],
+};
+function pluginConfiguration(key:string,node:ts.Expression,env:NodeJS.ProcessEnv):{value:Data;definition:Data} {
+  const f=fields(node),value:Data={},definition:Data={};
+  if(key==='gasReporter'){
+    for(const [name,item] of f){
+      if(name==='enabled'){
+        const n=unwrap(item);
+        if(ts.isPrefixUnaryExpression(n)&&n.operator===ts.SyntaxKind.ExclamationToken&&ts.isPrefixUnaryExpression(n.operand)&&n.operand.operator===ts.SyntaxKind.ExclamationToken){
+          const flag=secret(n.operand.operand,env);if(flag.definition.kind!=='env')return fail();value[name]=!!flag.value;definition[name]={kind:'boolean-env',source:flag.definition};
+        }else{const flag=data(n);if(typeof flag!=='boolean')return fail();value[name]=definition[name]=flag;}
+      }else if(name==='currency'){value[name]=definition[name]=data(item);if(typeof value[name]!=='string')return fail();}
+      else return fail();
+    }return {value,definition};
+  }
+  if(key==='etherscan'){
+    for(const [name,item] of f){
+      if(name==='apiKey'){
+        if(ts.isObjectLiteralExpression(unwrap(item))){value[name]={};definition[name]={};for(const [network,keyNode] of fields(item)){const api=secret(keyNode,env);value[name][network]=api.value;definition[name][network]=api.definition;}}
+        else{const api=secret(item,env);value[name]=api.value;definition[name]=api.definition;}
+      }else if(name==='enabled'){const enabled=data(item);if(typeof enabled!=='boolean')return fail();value[name]=definition[name]=enabled;}
+      else return fail();
+    }return {value,definition};
+  }
+  const parsed=data(node);
+  if(key==='zksolc'){
+    keys(parsed,['version','compilerSource','settings']);compiler(parsed.version);
+    if(parsed.compilerSource!==undefined&&!['binary','docker'].includes(parsed.compilerSource))return fail();
+    if(parsed.settings){keys(parsed.settings,['optimizer','isSystem','forceEvmla','libraries','enableEraVMExtensions']);if(parsed.settings.optimizer)keys(parsed.settings.optimizer,['enabled','mode','fallback_to_optimizing_for_size']);}
+  }else keys(parsed,pluginFields[key]??[]);
+  return {value:parsed,definition:parsed};
+}
 export interface ParsedConfiguration { userConfig:Data; definition:Data; plugins:string[]; explicitDate:boolean }
 /** Internal only: callers must not expose userConfig, which contains private evaluated capabilities. */
 export function parseConfigurationDefinition(bytes:Buffer,selected:string,env:NodeJS.ProcessEnv=process.env):ParsedConfiguration {
@@ -129,6 +187,7 @@ export function parseConfigurationDefinition(bytes:Buffer,selected:string,env:No
     const {file,fields:top,networks}=parseProjectConfig(new TextDecoder('utf-8',{fatal:true}).decode(bytes));
     const rpc=projectRpcSyntax(file);
     const plugins:string[]=[];
+    const aliases=new Map<string,ts.Expression>(),usedAliases=new Set<string>();
     let credentialResolver=false;
     const exported=unwrap(file.statements.filter(ts.isExportAssignment)[0].expression);
     for(const statement of file.statements){
@@ -143,18 +202,30 @@ export function parseConfigurationDefinition(bytes:Buffer,selected:string,env:No
             credentialResolver=true;
           }else if(name!=='hardhat/config'||!clause.isTypeOnly||clause.name||!clause.namedBindings||!ts.isNamedImports(clause.namedBindings)||clause.namedBindings.elements.some(e=>e.name.text!=='HardhatUserConfig'||e.propertyName))fail();
         }
-        else {if(!['gate-evm-tools/delivery-hardhat','@nomicfoundation/hardhat-ethers','@nomicfoundation/hardhat-chai-matchers','@openzeppelin/hardhat-upgrades'].includes(name)||plugins.includes(name))fail();plugins.push(name);}
-      }else if(ts.isVariableStatement(statement)){if(!ts.isIdentifier(exported)||statement.declarationList.declarations[0]?.name.getText(file)!==exported.text||statement.modifiers?.length||statement.declarationList.declarations.length!==1||!(statement.declarationList.flags&ts.NodeFlags.Const)||file.statements.filter(ts.isVariableStatement).length!==1)fail();}
+        else {if(!pluginsSupported.has(name)||plugins.includes(name))fail();plugins.push(name);}
+      }else if(ts.isVariableStatement(statement)){
+        if(statement.modifiers?.length||statement.declarationList.declarations.length!==1||!(statement.declarationList.flags&ts.NodeFlags.Const))fail();
+        const declaration=statement.declarationList.declarations[0];
+        if(!ts.isIdentifier(declaration.name)||!declaration.initializer)return fail();
+        if(ts.isIdentifier(exported)&&declaration.name.text===exported.text)continue;
+        if(aliases.has(declaration.name.text))fail();aliases.set(declaration.name.text,unwrap(declaration.initializer));
+      }
       else if(!ts.isExportAssignment(statement))fail();
     }
     if(plugins.includes('gate-evm-tools/delivery-hardhat')&&plugins[0]!=='gate-evm-tools/delivery-hardhat')fail();
     const userConfig:Data={},definition:Data={networks:{},plugins};
-    for(const [key,node] of top){if(!['solidity','networks','paths','defaultNetwork'].includes(key))fail();if(key!=='networks')userConfig[key]=definition[key]=data(node);}
+    for(const [key,node] of top){
+      if(['solidity','networks','paths','defaultNetwork'].includes(key)){if(key!=='networks')userConfig[key]=definition[key]=data(node);}
+      else if(['zksolc','gasReporter','etherscan',...Object.keys(pluginFields)].includes(key)){const item=pluginConfiguration(key,node,env);userConfig[key]=item.value;definition[key]=item.definition;}
+      else fail();
+    }
     if(!('solidity'in userConfig))fail();compiler(userConfig.solidity);
     if(userConfig.paths){keys(userConfig.paths,['sources','cache','artifacts','tests']);for(const value of Object.values(userConfig.paths))if(typeof value!=='string'||!value||value.startsWith('/')||value.includes('\\')||value.split('/').some(p=>!p||p==='..'))fail();}
     if(userConfig.defaultNetwork!==undefined)validateNetworkAlias(userConfig.defaultNetwork,'defaultNetwork');
-    userConfig.networks={};for(const [name,node] of networks){validateNetworkAlias(name,'network');const n=network(node,name==='hardhat',env,rpc.helper,credentialResolver);userConfig.networks[name]=n.value;definition.networks[name]=n.definition;}
-    if(!userConfig.networks[selected])fail();
+    userConfig.networks={};for(const [name,node] of networks){validateNetworkAlias(name,'network');const n=network(node,name==='hardhat',env,rpc.helper,credentialResolver,aliases,usedAliases);userConfig.networks[name]=n.value;definition.networks[name]=n.definition;}
+    if([...aliases.keys()].some(name=>!usedAliases.has(name)))fail();
+    const target=userConfig.networks[selected];
+    if(!target||!Number.isSafeInteger(target.chainId)||target.chainId<=0||target.zksync===true)fail();
     return {userConfig,definition:deepFreeze(definition),plugins,explicitDate:Object.hasOwn(userConfig.networks.hardhat??{},'initialDate')};
   }catch{throw new Error('Unsupported static delivery configuration');}
 }

package/runtime/delivery/configuration-hre.ts

@@ -118,7 +118,7 @@ export function observeConfigurationHre(root:string,selected:string,parsed:Parse
   }
   const resolved=check(parsed),paths:Data={root:'.',configFile:'hardhat.config.ts'};
   for(const name of ['sources','cache','artifacts','tests']){const relative=path.relative(root,resolved.paths[name]).split(path.sep).join('/');paths[name]=relative;}
-  const {url:_url,accounts:_accounts,httpHeaders:_headers,...http}=resolved.networks[selected];
+  const {url:_url,accounts:_accounts,httpHeaders:_headers,ethNetwork:_ethNetwork,...http}=resolved.networks[selected];
   const {accounts:_runnerAccounts,forking:_fork,initialDate:_date,...runner}=originalRunnerPolicy(resolved as any);
   const runnerPublic:Data=configurationData(runner);
   runnerPublic.accounts=parsed.definition.networks.hardhat?.accounts??{kind:'hardhat-default-hd'};

package/runtime/delivery/configuration.ts

@@ -1,7 +1,7 @@
 /** Owned configuration/runtime contributor. It grants no planning, signing or execution authority. */
 import path from 'node:path';
 import {projectRoot,parseDeliveryProjectMarker} from './project-files';
-import {readInputBytes,inputDigest} from './input-files';
+import {readInputBytes,readOptionalInputBytes,inputDigest} from './input-files';
 import {parseConfigurationDefinition} from './configuration-definition';
 import {observeConfigurationHre} from './configuration-hre';
 import {RuntimeObservation,type RuntimeEvidence} from './configuration-runtime';
@@ -34,14 +34,14 @@ export function openDeliveryConfiguration(raw:DeliveryConfigurationOptions):Deli
     exactObject(raw,['workspaceRoot','projectRoot','network'],'configuration options');
     const root=projectRoot(raw.workspaceRoot,raw.projectRoot);
     if(path.resolve(process.cwd())!==root)throw new Error();
-    const config=readInputBytes(root,'hardhat.config.ts'),marker=readInputBytes(root,'.gate-template.json');
+    const config=readInputBytes(root,'hardhat.config.ts'),marker=readOptionalInputBytes(root,'.gate-template.json');
     // Marker describes generation provenance; current source is independently observed.
-    parseDeliveryProjectMarker(marker);
+    if(marker!==undefined)parseDeliveryProjectMarker(marker);
     const parse=(bytes:Buffer)=>parseConfigurationDefinition(bytes,raw.network,projectRpcEnvironment(root,bytes.toString('utf8'),process.env));
     const parsed=parse(config);
     runtime=new RuntimeObservation(root);codec=openPlanCodecObservation();
     const hre=observeConfigurationHre(root,raw.network,parsed,runtime.files);
-    const files=[{path:'hardhat.config.ts',digest:inputDigest(config)},{path:'.gate-template.json',digest:inputDigest(marker)}];
+    const files=[{path:'hardhat.config.ts',digest:inputDigest(config)},...(marker===undefined?[]:[{path:'.gate-template.json',digest:inputDigest(marker)}])];
     const observe=():DeepReadonly<DeliveryConfigurationEvidence>=>{
       // Reuse the actual owned compiler association when present, without recapturing any compiler jobs.
       const {ownedDeliveryCompiler}=require('./compiler') as typeof import('./compiler');
@@ -54,7 +54,9 @@ export function openDeliveryConfiguration(raw:DeliveryConfigurationOptions):Deli
     const close=()=>{runtime!.close();codec!.close();};
     const check=()=>{
       const current=readInputBytes(root,'hardhat.config.ts');
-      if(inputDigest(current)!==files[0].digest||inputDigest(readInputBytes(root,'.gate-template.json'))!==files[1].digest)throw new Error();
+      const currentMarker=readOptionalInputBytes(root,'.gate-template.json');
+      if(inputDigest(current)!==files[0].digest||(marker===undefined)!==(currentMarker===undefined)
+        ||(currentMarker!==undefined&&inputDigest(currentMarker)!==files[1].digest))throw new Error();
       hre.assertUnchanged(parse(current));codec!.assertUnchanged();runtime!.assertUnchanged();
     };
     const assertOpen=()=>{if(status!=='open')throw new Error('Delivery configuration session closed');};

package/runtime/delivery/custom-format.ts

@@ -318,7 +318,7 @@ export function parseCustomOperations(raw: unknown): WorkflowStep[] {
   return deepFreeze(operations);
 }
 export interface CustomObservation {
-  kind: "json" | "bytes" | "resolve";
+  kind: "json" | "bytes" | "resolve" | "contract";
   key: string;
   value: unknown;
   digest: string;
@@ -331,6 +331,7 @@ export interface CustomEvidence {
   module: { path: string; digest: string };
   input: unknown;
   declarations: {
+    chain?: boolean;
     files: string[];
     params: string[];
     state: string[];
@@ -344,10 +345,11 @@ export interface CustomEvidence {
 export function parseDeclarations(raw: unknown): CustomEvidence["declarations"] {
   const decl = exactObject(
     raw,
-    ["files", "params", "state", "target"],
+    ["files", "params", "state", "target", ...(Object.hasOwn(raw as object,"chain")?["chain"]:[])],
     "custom declarations"
   );
   for (const [key, values] of Object.entries(decl)) {
+    if(key==='chain'){if(typeof values!=='boolean')throw Error('chain declaration must be boolean');continue;}
     if (
       !Array.isArray(values) ||
       values.some((v) => typeof v !== "string" || !v || v.trim() !== v) ||
@@ -428,11 +430,17 @@ export function parseCustomEvidence(raw: unknown): CustomEvidence {
       "custom observation"
     );
     if (
-      !["json", "bytes", "resolve"].includes(String(o.kind)) ||
+      !["json", "bytes", "resolve", "contract"].includes(String(o.kind)) ||
       o.digest !== semanticHash(o.value)
     )
       throw new Error("Custom observation mismatch");
     const key = nonempty(o.key, "observation key");
+    if (o.kind === "contract") {
+      if(!declarations.chain||o.bytesDigest!==null||o.inputPath!==null)throw Error("Undeclared chain query");
+      const evidence=require('./query').parseContractQueryEvidence(o.value);
+      if(key!==evidence.method)throw Error('Query observation method mismatch');
+      continue;
+    }
     if (o.kind === "resolve") {
       if (o.inputPath !== null)
         throw new Error("Invalid resolved observation path");

package/runtime/delivery/custom.ts

@@ -56,6 +56,7 @@ export function ownedCustomSession(
   return owned;
 }
 interface CustomSessionInputs {
+  query?: (query: import('./scripts').ContractQuery) => Promise<{value:unknown;evidence:unknown}>;
   root: string;
   businessRoot: string;
   params: Record<string, unknown>;
@@ -133,6 +134,11 @@ export class CustomPlanningSession implements CustomPlanningInputSession {
       return this.#closure.readData(this.#input.businessRoot, name);
     };
     const ports = Object.freeze({
+      readContract: async (query: import('./scripts').ContractQuery) => {
+        assertOpen();if(!declarations.chain||!this.#input.query)throw Error('Declared controlled chain query port required');
+        const normalized=this.#closure.normalize(query) as import('./scripts').ContractQuery;
+        const result=await this.#input.query(normalized);assertOpen();observe('contract',normalized.method,result.evidence);return deepFreeze(strictData(result.value));
+      },
       readJson: async (name: string) => {
         const { bytes, path: inputPath } = read(name);
         return observe(
@@ -192,6 +198,10 @@ export class CustomPlanningSession implements CustomPlanningInputSession {
         throw new Error(
           "Custom planning must export planOperations; legacy exports are rejected"
         );
+      for(const prerequisite of (s.input as any)?.prerequisites??[]){
+        const resolve=(v:any):any=>typeof v==='string'&&v.startsWith('$')?ports.resolve(v.slice(1)):Array.isArray(v)?v.map(resolve):v&&typeof v==='object'?Object.fromEntries(Object.entries(v).map(([k,x])=>[k,resolve(x)])):v;
+        const {expect,...query}=resolve(prerequisite);const actual=await ports.readContract(query);require('./query').requireQueryResult({...query,expect},actual);
+      }
       operations = parseCustomOperations(
         this.#closure.normalize(
           await mod.planOperations(
@@ -200,6 +210,9 @@ export class CustomPlanningSession implements CustomPlanningInputSession {
           )
         )
       );
+      if(mod.delivery!==undefined)for(const operation of operations.filter(o=>['deploy','upgrade','call'].includes(o.kind))){
+        if(typeof operation.name!=='string'||!operation.name.trim()||typeof operation.description!=='string'||!operation.description.trim())throw Error(`Business operation ${operation.id} requires name and description before approval`);
+      }
       this.#closure.assertUnchanged();
     } finally {
       open = false;

package/runtime/delivery/development-inputs.ts

@@ -0,0 +1,73 @@
+/** One immutable copy of the original development preparation, reused by release history. */
+import fs from 'node:fs';
+import path from 'node:path';
+import {randomUUID} from 'node:crypto';
+import {canonicalJson} from '../workflow/lib/canonicalData';
+import {developmentPath,byteHash} from './materialization';
+import {readInputBytes} from './input-files';
+import {projectRoot} from './project-files';
+import {parseDeliveryPlan} from './plan';
+import {safeId} from './protocol';
+import type {DeliveryAggregate,DeliveryAggregateOptions} from './aggregate';
+
+/** Publish complete bytes without replacing another writer's immutable file. */
+export function writeImmutableDeliveryFile(root:string,relative:string,bytes:Buffer):{path:string;sha256:string} {
+ const file=developmentPath(root,relative);
+ const existing=()=>{if(!readInputBytes(root,relative).equals(bytes))throw Error(`Immutable delivery file conflict: ${relative}`);};
+ if(fs.existsSync(file)){existing();return {path:relative,sha256:byteHash(bytes)};}
+ fs.mkdirSync(path.dirname(file),{recursive:true,mode:0o700});
+ const temporary=`${file}.${randomUUID()}.tmp`,fd=fs.openSync(temporary,'wx',0o600);
+ try{fs.writeFileSync(fd,bytes);fs.fsyncSync(fd);}finally{fs.closeSync(fd);}
+ try{
+  try{fs.linkSync(temporary,file);}catch(error){if((error as NodeJS.ErrnoException).code!=='EEXIST')throw error;existing();}
+ }finally{fs.unlinkSync(temporary);}
+ const directory=fs.openSync(path.dirname(file),'r');try{fs.fsyncSync(directory);}finally{fs.closeSync(directory);}
+ return {path:relative,sha256:byteHash(bytes)};
+}
+
+export function persistDevelopmentInputs(input:{root:string;source:DeliveryAggregateOptions;aggregate:DeliveryAggregate}):{sourcePath:string;aggregatePath:string} {
+ const root=fs.realpathSync(input.root),{source,aggregate}=input,plan=parseDeliveryPlan(aggregate.collections[0]?.plan);
+ if(source.selection!=='development'||source.targets.length!==1||aggregate.collections.length!==1||plan.environment!=='dev'
+  ||projectRoot(source.workspaceRoot,source.projectRoot)!==root||source.targets[0].executionId!==plan.executionId||source.targets[0].request.network!==plan.target)
+  throw Error('Development inputs require the original single-target preparation');
+ const id=safeId(plan.executionId,'executionId'),base=`.gate-delivery/development/${id}`;
+ const sourcePath=`${base}.source.json`,aggregatePath=`${base}.aggregate.json`;
+ // Check both existing inputs before publishing either file.
+ const entries:[[string,unknown],[string,unknown]]=[[sourcePath,source],[aggregatePath,aggregate]];
+ for(const [file,value]of entries)if(fs.existsSync(developmentPath(root,file))&&canonicalJson(JSON.parse(readInputBytes(root,file).toString()))!==canonicalJson(value))
+  throw Error(`Immutable delivery file conflict: ${file}`);
+ // Existing preparation bytes remain authoritative, including their original JSON formatting.
+ for(const [file,value]of entries)if(!fs.existsSync(developmentPath(root,file)))writeImmutableDeliveryFile(root,file,Buffer.from(canonicalJson(value)+'\n'));
+ const snapshotPath=`${base}.inputs.snapshot.json`;
+ const expected=aggregate.inputs.files.filter(f=>!f.path.split('/').includes('node_modules'));
+ if(fs.existsSync(developmentPath(root,snapshotPath))){
+  const snapshot=JSON.parse(readInputBytes(root,snapshotPath).toString());
+  if(snapshot.schema!=='gate-delivery-development-inputs'||snapshot.version!==1||snapshot.inputsHash!==aggregate.inputsHash||!Array.isArray(snapshot.files)
+   ||canonicalJson(snapshot.files.map(({path,digest}:any)=>({path,digest})))!==canonicalJson(expected))throw Error('Original preparation snapshot identity mismatch');
+  for(const file of snapshot.files)if(typeof file.base64!=='string'||byteHash(Buffer.from(file.base64,'base64'))!==file.digest)throw Error('Original preparation snapshot bytes mismatch');
+ }else{
+  const files=expected.map(f=>{const bytes=readInputBytes(root,f.path);if(byteHash(bytes)!==f.digest)throw Error(`Preparation snapshot drift: ${f.path}`);return {...f,base64:bytes.toString('base64')};});
+  writeImmutableDeliveryFile(root,snapshotPath,Buffer.from(canonicalJson({schema:'gate-delivery-development-inputs',version:1,inputsHash:aggregate.inputsHash,files})+'\n'));
+ }
+ return {sourcePath,aggregatePath};
+}
+
+/** A host may replace an unsigned preparation only while holding the original durable execution claim. */
+export async function invalidateDevelopmentPreparation(input:{root:string;executionId:string;store:import('./execution-store').ExecutionStore}){
+ const id=safeId(input.executionId,'executionId'),aggregate=JSON.parse(readInputBytes(input.root,`.gate-delivery/development/${id}.aggregate.json`).toString()),plan=parseDeliveryPlan(aggregate.collections[0]?.plan);
+ if(plan.executionId!==id||plan.environment!=='dev')throw Error('Original development preparation required');
+ const releases=path.join(input.root,`scripts/tasks/${plan.deploymentId}/releases`);
+ if(fs.existsSync(releases)&&fs.readdirSync(releases).some(name=>fs.existsSync(path.join(releases,name,'release.json'))))throw Error('Frozen release cannot be re-prepared; create a new round');
+ const marker=`.gate-delivery/development/${id}.superseded.json`;
+ const finality={kind:'confirmations',depth:String(Math.max(1,aggregate.inputs.business.targets[0].finality.confirmations))};
+ const {semanticHash}=require('../workflow/lib/canonicalData') as typeof import('../workflow/lib/canonicalData');
+ const context={executionId:id,planHash:plan.planHash,releaseHash:plan.inputsHash,operator:plan.operator,chainId:plan.chainId,target:plan.target,finality,policyHash:semanticHash(finality)};
+ const previous=await input.store.readExecution(id);
+ await input.store.withExecutionClaim({plan,contextHash:semanticHash({schema:'gate-delivery-eoa-context',version:1,context}),expectedRevision:previous?.revision??null},async(claim,state)=>{
+  if(state.transactions.some(t=>t.state!=='claimed'||t.unsigned!==null||t.signingRequestId!==null)||state.completedCount||state.safeEnvelopes.length)throw Error('Signing or execution already started; recover original execution or create a new round');
+  if(state.blockedReason!==null&&state.blockedReason!=='Superseded before signing')throw Error('Original execution is blocked for another reason');
+  if(state.blockedReason===null)input.store.blockExecution(claim,state.revision,'Superseded before signing');
+  writeImmutableDeliveryFile(input.root,marker,Buffer.from(canonicalJson({version:1,executionId:id,planHash:plan.planHash,reason:'reprepare-before-signing'})+'\n'));
+ });
+ return {deploymentId:plan.deploymentId,values:aggregate.inputs.business.parameters[0].resolved.values};
+}

package/runtime/delivery/development.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {createRequire} from 'node:module';
 import ts from 'typescript';
-import {existingCodeCoverage,requiredExistingAddresses} from './existing-code';
+import {existingCodeCoverage,requiredExistingAddresses,interactionCoverageRegistry} from './existing-code';
 import {yieldCompilerIo} from './compiler-io';
 import {openDeliveryConfiguration} from './configuration';
 import {aggregateInputHash} from './execution-identity';
@@ -25,6 +25,7 @@ import {DeliveryOperationIdentities} from './identities';
 import {parsePreparationJournal,type PreparationEntry} from './journal';
 import type {DeliveryCollection} from './planning';
 import type {DeliveryAggregate,DeliveryAggregateOptions} from './aggregate';
+export {persistDevelopmentInputs,invalidateDevelopmentPreparation} from './development-inputs';
 import {openAggregateSources} from './aggregate-inputs';
 import {loadDeliveryPublicTarget} from './config';
 import {inputDigest,readInputBytes} from './input-files';
@@ -115,6 +116,7 @@ export async function createDevelopmentDelivery(options:DevelopmentDeliveryOptio
  const identity=semanticHash({schema:'gate-delivery-development',version:1,executionId:plan.executionId,planHash:plan.planHash,target:plan.target,inputsHash:computed,sourceDefinitionHash:plan.sourceDefinitionHash,runtimeIdentity:plan.runtimeIdentity,context:options.execution.context});
  const recordPath=`scripts/tasks/${plan.deploymentId}/results/${plan.target}/${plan.executionId}/deployment.json`,sessionPath=`.gate-delivery/development/${plan.executionId}.json`;
  async function assertCurrent(){
+  if(fileBytes(root,`.gate-delivery/development/${plan.executionId}.superseded.json`)!==null)throw Error('Preparation superseded before signing; use the replacement execution');
   if(createRequire(path.join(root,'package.json'))('hardhat')!==hre)throw Error('Development requires the actual validated project HRE');
   const observation=openDeliveryConfiguration({workspaceRoot:source.workspaceRoot,projectRoot:source.projectRoot,network:plan.target});
   try {
@@ -156,7 +158,7 @@ export async function createDevelopmentDelivery(options:DevelopmentDeliveryOptio
   const session={version:1,manifests,identity,planHash:plan.planHash,recordPath,registry:validateContractInfo(JSON.parse(fileBytes(root,'contractInfo.json')??'{}')),metadata:validateDeploymentInfo(JSON.parse(fileBytes(root,'deploymentInfo.json')??'{"version":1,"networks":{}}'))};
   atomicDevelopmentWrite(root,sessionPath,json(session));return session;
  });
- function pureCoverage(){return existingCodeCoverage({target:plan.target,addresses:requiredExistingAddresses(collection!),registry:base.registry,metadata:base.metadata,compiler:rows.find(r=>r.target===plan.target)!.compiler,manifests:base.manifests??[]});}
+ function pureCoverage(){return existingCodeCoverage({target:plan.target,addresses:requiredExistingAddresses(collection!),registry:interactionCoverageRegistry(collection!,base.registry,plan.target),metadata:base.metadata,compiler:rows.find(r=>r.target===plan.target)!.compiler,manifests:base.manifests??[]});}
  async function assertExistingCode(){
   if(preparations.length)return;
   const coverage=pureCoverage(),checker=new BytecodeChecker(hre,{},'evm');

package/runtime/delivery/execution-records.ts

@@ -0,0 +1,31 @@
+/** Source-neutral preparation locators. These files identify inputs; approval remains a host capability. */
+import fs from 'node:fs';
+import {randomUUID} from 'node:crypto';
+import {safeId,address} from './protocol';
+import {readInputBytes} from './input-files';
+import {developmentPath,withDevelopmentFileLock} from './materialization';
+import {writeImmutableDeliveryFile} from './development-inputs';
+import {canonicalJson,deepFreeze} from '../workflow/lib/canonicalData';
+import type {ProductionOptions} from './production';
+export const executionRecordPath=(id:string)=>`.gate-delivery/executions/${safeId(id,'executionId')}.json`;
+export function readExecutionRecord(root:string,id:string){return JSON.parse(readInputBytes(root,executionRecordPath(id)).toString());}
+export function saveExecutionRecord(root:string,record:{kind:'development'|'production';deploymentId:string;executionId:string;[key:string]:unknown}){
+ safeId(record.deploymentId,'deploymentId');safeId(record.executionId,'executionId');
+ writeImmutableDeliveryFile(root,executionRecordPath(record.executionId),Buffer.from(canonicalJson(record)+'\n'));return record;
+}
+/** A release/target has one execution, including when its approving host changes. */
+export async function claimProductionExecution(root:string,input:Omit<ProductionOptions,'executionId'>){
+ input={...input,operator:address(input.operator,'operator').toLowerCase()};
+ const index=`.gate-delivery/releases/${safeId(input.releaseRef.releaseId,'releaseId')}/${safeId(input.target,'target')}.execution.json`;
+ return withDevelopmentFileLock(root,async()=>{
+  if(fs.existsSync(developmentPath(root,index))){
+   const prior=JSON.parse(readInputBytes(root,index).toString());
+   const {executionId,...scope}=prior.options??{};
+   if(prior.kind!=='production'||canonicalJson(scope)!==canonicalJson(input)||prior.executionId!==executionId)throw Error('Original production execution scope mismatch; reconcile the original execution');
+   const descriptor=readExecutionRecord(root,executionId);if(canonicalJson(descriptor)!==canonicalJson(prior))throw Error('Original production preparation locator mismatch');
+   return deepFreeze(prior);
+  }
+  const executionId=randomUUID(),record={kind:'production' as const,deploymentId:input.deploymentId,executionId,options:{...input,executionId}};
+  saveExecutionRecord(root,record);writeImmutableDeliveryFile(root,index,Buffer.from(canonicalJson(record)+'\n'));return deepFreeze(record);
+ });
+}

package/runtime/delivery/existing-code.ts

@@ -1,7 +1,7 @@
 /** Pure-call coverage from the accepted registration and owned compiler witness. No deployments are invented. */
 import {TRANSPARENT_PROXY_ARTIFACT,PROXY_ADMIN_ARTIFACT,transparentAdminAddress,artifactIdentity,parseTargetManifest,hashStorageLayout} from 'gate-evm-tools/workflow';
 import {canonicalJson,semanticHash} from '../workflow/lib/canonicalData';
-import {validateContractInfo} from '../workflow/lib/deployments';
+import {validateContractInfo,type ContractInfo} from '../workflow/lib/deployments';
 import {validateDeploymentInfo} from '../workflow/lib/deploymentInfo';
 import {byteHash} from './materialization';
 import type {CompilerEvidence} from './compiler';
@@ -43,3 +43,14 @@ export async function collectExistingCodeArtifacts(input:{target:string;addresse
  for(const address of new Set(input.addresses.map(a=>a.toLowerCase()))){const entries=Object.entries(registry).filter(([,a])=>a.toLowerCase()===address);if(entries.length!==1)throw Error('Existing code target requires unique frozen registration');const [key]=entries[0],m=metadata[key.split(':')[0]];names.add(m?.actualContract??key.split(':').at(-1)!);if(m?.proxyKind==='uups'||m?.proxyKind==='transparent'){names.add(m.proxyKind==='transparent'?TRANSPARENT_PROXY_ARTIFACT:'@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol:ERC1967Proxy');if(m.proxyKind==='transparent')names.add(PROXY_ADMIN_ARTIFACT);}}
  for(const name of names)await input.readArtifact(name);
 }
+
+/** Ephemeral interaction bindings for explicitly addressed contracts. Never written as deployment records. */
+export function interactionCoverageRegistry(collection:Pick<DeliveryCollection,'plan'|'verification'>,registry:unknown,target:string):ContractInfo{
+ const copy=JSON.parse(canonicalJson(validateContractInfo(registry)));copy[target]??={};
+ const bindings=new Map<string,string>();
+ const bind=(address:unknown,contract:unknown)=>{if(typeof address!=='string'||!/^0x[\da-f]{40}$/i.test(address)||typeof contract!=='string')return;const a=address.toLowerCase(),old=bindings.get(a);if(old&&old!==contract)throw Error('Conflicting explicit interaction artifact');bindings.set(a,contract);};
+ for(const a of collection.verification)bind(a.address,a.abiName);
+ for(const c of collection.plan.customBindings)for(const op of c.operations)if(['call','view','check'].includes(op.kind))bind(op.address,op.abi??op.contract);
+ for(const [a,contract]of bindings)if(!Object.values(copy[target]).some(v=>(v as string).toLowerCase()===a))copy[target][`interaction_${a.slice(2,14)}:${contract}`]=a;
+ return copy;
+}

package/runtime/delivery/history-package.ts

@@ -0,0 +1,50 @@
+/** Verify retained producer bytes in memory. Historical code is never extracted or executed. */
+import {createHash} from 'node:crypto';
+import {gunzipSync} from 'node:zlib';
+import {byteHash} from './materialization';
+import {object,portablePath} from './protocol';
+import {canonicalJson} from '../workflow/lib/canonicalData';
+import type {DeliveryAggregate} from './aggregate';
+
+export function readHistoricalPackage(archive:Buffer,archiveFile:string,aggregate:DeliveryAggregate):ReadonlyMap<string,Buffer> {
+ if(archiveFile!==`.gate-delivery/packages/${byteHash(archive)}.json.gz`)throw Error('Historical archive content address mismatch');
+ const snapshot=object(JSON.parse(gunzipSync(archive,{maxOutputLength:128*1024*1024}).toString()),'historical package snapshot',['schema','version','runtimeIdentity','observedPackage','files']);
+ if(snapshot.schema!=='gate-delivery-package-snapshot'||snapshot.version!==2||!Array.isArray(snapshot.files))throw Error('Invalid historical package snapshot archive');
+ const original=aggregate.inputs.runtime.package;
+ const same=(a:unknown,b:unknown,label:string)=>{if(canonicalJson(a)!==canonicalJson(b))throw Error(`${label} mismatch`);};
+ same(snapshot.observedPackage,original,'Historical snapshot provenance');
+ same(snapshot.runtimeIdentity,aggregate.inputs.runtime.declared,'Historical snapshot runtime');
+ const files=new Map<string,Buffer>();
+ for(const raw of snapshot.files){
+  const file=object(raw,'historical package member',['path','digest','base64']),relative=portablePath(file.path,'historical package member');
+  if(relative.split('/').includes('node_modules')||files.has(relative)||typeof file.base64!=='string')throw Error('Invalid historical package member');
+  const bytes=Buffer.from(file.base64,'base64');
+  if(bytes.toString('base64')!==file.base64||byteHash(bytes)!==file.digest)throw Error('Historical snapshot archive bytes mismatch');
+  files.set(relative,bytes);
+ }
+ const payload=[...files].map(([path,bytes])=>({path,digest:byteHash(bytes)}));
+ same(payload,original.payload,'Historical archive complete payload');
+ same(byteHash(payload.map(f=>`${f.path}\0${f.digest}\n`).join('')),original.payloadDigest,'Historical payload digest');
+ // Match the producer's sorted directory traversal, including file/directory prefix ordering.
+ const children=new Map<string,Set<string>>();
+ for(const relative of files.keys()){
+  const parts=relative.split('/');let directory='';
+  for(let i=0;i<parts.length;i++){
+   if(files.has(directory))throw Error('Historical package file/directory collision');
+   if(!children.has(directory))children.set(directory,new Set());
+   children.get(directory)!.add(parts[i]);directory=directory?`${directory}/${parts[i]}`:parts[i];
+  }
+ }
+ const digest=createHash('sha256');
+ const visit=(directory:string)=>{
+  const names=children.get(directory);if(!names)throw Error('Historical executable directory missing');
+  for(const name of [...names].sort()){
+   const relative=`${directory}/${name}`,bytes=files.get(relative);
+   if(bytes){if(/\.(?:c?js)$/.test(relative)){digest.update(relative);digest.update(bytes);}}
+   else visit(relative);
+  }
+ };
+ for(const directory of ['dist-runtime','dist','dist-cjs','bin'])visit(directory);
+ same(digest.digest('hex'),aggregate.inputs.runtime.declared.digest,'Historical executable runtime digest');
+ return files;
+}

package/runtime/delivery/input-files.ts

@@ -3,9 +3,13 @@ import fs from 'node:fs';
 import { createHash } from 'node:crypto';
 import YAML from 'yaml';
 import { strictData } from './data';
-import { confinedFile } from './project-files';
+import { confinedFile, stat } from './project-files';
 
 export const inputDigest = (bytes: string | Buffer): string => createHash('sha256').update(bytes).digest('hex');
+/** Absence is an observed input too; unsafe existing paths still fail. */
+export function readOptionalInputBytes(root: string, relative: string): Buffer | undefined {
+  return stat(confinedFile(root, relative)) ? readInputBytes(root, relative) : undefined;
+}
 export function readInputBytes(root: string, relative: string): Buffer {
   const file = confinedFile(root, relative);
   const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);

package/runtime/delivery/inputs.ts

@@ -77,7 +77,7 @@ export function openDeliveryInputs(raw: DeliveryInputOptions): DeliveryInputHand
   if (!['development', 'release', 'all'].includes(input.selection)) throw new Error('Unsupported delivery input selection');
   const sourceInput = { workspaceRoot: input.workspaceRoot, projectRoot: input.projectRoot, request: input.request };
   const source = readOwnedDeliverySource(sourceInput);
-  const scope = object(source.invocation.task.scope?.deployment, 'deployment');
+  const scope = source.scope;
   const deploymentId = safeId(scope.deploymentId, 'deploymentId'), businessRoot = `scripts/tasks/${deploymentId}`;
   const files: DeliveryInputSnapshot['files'] = [];
   const read = (name: string, format: 'json' | 'yaml') => {
@@ -85,9 +85,9 @@ export function openDeliveryInputs(raw: DeliveryInputOptions): DeliveryInputHand
     files.push({ path: relative, digest: inputDigest(bytes) });
     return parseInputDocument(bytes, format);
   };
-  const task = object(read('task.yaml', 'yaml'), 'task.yaml', ['version', 'id', 'developmentNetwork', 'releaseTargetNetworks', 'requirementRef', 'productionRequirementRef', 'referenceDeploymentId']);
-  if (task.version !== 1 || task.id !== deploymentId) throw new Error('Task version/deployment identity mismatch');
-  same(parseDeploymentRequirementRef(task.requirementRef), scope.requirementRef, 'Task requirementRef');
+  const task = object(read('task.yaml', 'yaml'), 'task.yaml', ['version', 'id', 'developmentNetwork', 'releaseTargetNetworks', 'requirementRef', 'productionRequirementRef', 'referenceDeploymentId', 'source', 'script', 'selectedSteps', 'description']);
+  if (task.version !== (source.kind==='standalone'?2:1) || task.id !== deploymentId) throw new Error('Task version/deployment identity mismatch');
+  if(source.kind==='gateflow')same(parseDeploymentRequirementRef(task.requirementRef), scope.requirementRef, 'Task requirementRef');
   same(task.referenceDeploymentId ?? null, scope.referenceDeploymentId ?? null, 'Task referenceDeploymentId');
   same(task.developmentNetwork, scope.developmentNetwork, 'Task developmentNetwork');
   const release = task.releaseTargetNetworks as string[];
@@ -103,6 +103,10 @@ export function openDeliveryInputs(raw: DeliveryInputOptions): DeliveryInputHand
   if (manifest.id !== deploymentId) throw new Error('Manifest deployment identity mismatch');
   if (manifest.description !== undefined) nonempty(manifest.description, 'manifest description');
   const steps = parseSteps(manifest.steps);
+  if(source.kind==='standalone'){
+    const expected=require('./scripts').scriptManifest(source.projectRoot,task.script,task.selectedSteps);
+    same(steps,expected.steps,'Native script and selected business steps');
+  }
   const schema = object(read('parameters.schema.json', 'json'), 'parameters schema');
   const dev = scope.developmentNetwork as string;
   const all = [dev, ...release];
@@ -113,7 +117,7 @@ export function openDeliveryInputs(raw: DeliveryInputOptions): DeliveryInputHand
     const definition = exactObject(raw, ['version', 'module'], 'producer');
     nonempty(definition.version, 'producer version');
     const module = portablePath(definition.module, 'producer module');
-    if (!module.startsWith(`${businessRoot}/`)) throw new Error('Producer module is outside deployment business root');
+    if (!module.startsWith(`${businessRoot}/`) && !module.startsWith('scripts/operations/')) throw new Error('Producer module is outside deployment business root');
   }
   const selected = input.selection === 'development' ? [dev] : input.selection === 'release' ? release : all;
   // Both the digest and every public projection use these exact buffers. Reopening
@@ -188,7 +192,7 @@ export function openDeliveryInputs(raw: DeliveryInputOptions): DeliveryInputHand
       for(const {closure} of resolved.values())closure?.closeReads();
       const current = readOwnedDeliverySource(sourceInput);
       same(current.sourceDefinitionHash, source.sourceDefinitionHash, 'Business source definition');
-      same(current.invocation.task.scope?.deployment, scope, 'Business invocation');
+      same(current.scope, scope, 'Business invocation');
       for (const file of files) if (inputDigest(readInputBytes(source.projectRoot, file.path)) !== file.digest) throw new Error('Business input file drift');
       const parameters = [...resolved.values()].map(({ evidence, closure }) => {
         same(closure?.seal() ?? null, evidence.closure, 'Parameter producer closure');

package/runtime/delivery/materialization.ts

@@ -29,9 +29,16 @@ export function readDevelopmentJournal(root:string,executionId:string):any|undef
  for(const f of j.files){exactObject(f,['path','before','after','beforeHash','afterHash'],'journal file');portablePath(f.path,'journal path');if((f.before!==null&&typeof f.before!=='string')||typeof f.after!=='string'||f.beforeHash!==(f.before===null?null:byteHash(f.before))||f.afterHash!==byteHash(f.after))throw Error('Invalid materialization journal bytes');}
  if(new Set(j.files.map((f:any)=>f.path)).size!==j.files.length||j.intentHash!==semanticHash({version:j.version,executionId:j.executionId,identity:j.identity,files:j.files}))throw Error('Invalid materialization journal identity');return j;
 }
+const fileLockQueues=new Map<string,Promise<void>>();
 export async function withDevelopmentFileLock<T>(root:string,work:()=>Promise<T>):Promise<T> {
+ const key=fs.realpathSync(root),previous=fileLockQueues.get(key)??Promise.resolve();let release!:()=>void;
+ const queued=new Promise<void>(resolve=>{release=resolve;});fileLockQueues.set(key,queued);
+ await previous;
+ try{return await lockedDevelopmentFiles(key,work);}finally{release();if(fileLockQueues.get(key)===queued)fileLockQueues.delete(key);}
+}
+async function lockedDevelopmentFiles<T>(root:string,work:()=>Promise<T>):Promise<T> {
  const file=developmentPath(root,'.gate-delivery/materialization.sqlite');mkdir(path.dirname(file));const db=new DatabaseSync(file);
- try{db.exec('PRAGMA busy_timeout=5000; PRAGMA synchronous=FULL; BEGIN IMMEDIATE');return await work();}finally{try{db.exec('ROLLBACK');}finally{db.close();}}
+ let begun=false;try{db.exec('PRAGMA busy_timeout=5000; PRAGMA synchronous=FULL; BEGIN IMMEDIATE');begun=true;return await work();}finally{try{if(begun)db.exec('ROLLBACK');}finally{db.close();}}
 }
 /** Caller holds no file lock. onFileCommitted is a progress notification, never acceptance authority. */
 export async function commitDevelopmentFiles(input:DevelopmentFileCommit,onFileCommitted?:(path:string)=>void):Promise<any> {