@poe-platform/safe-bash 0.1.726 → 0.1.727

package/dist/safe-bash/commands/text-programs/awk-runtime.js

@@ -11,7 +11,7 @@ function textSize(value) {
 }
 function ownScalar(value) {
     return value.kind === "string" || value.kind === "numeric"
-        ? { ...value, text: Buffer.from(value.text, "latin1").toString("latin1") } : value;
+        ? { ...value, text: value.text.length < 13 ? value.text : Buffer.from(value.text, "latin1").toString("latin1") } : value;
 }
 class Flow {
     kind;
@@ -79,7 +79,13 @@ export class AwkRuntime {
     store(name) { return this.frames.at(-1)?.has(name) ? this.frames.at(-1) : this.variables; }
     get(name) { return this.store(name).get(name) ?? unset; }
     getScalar(name) { return scalar(this.get(name)); }
-    asText(value) { return text(value, text(this.getScalar("CONVFMT"), undefined, this.budget), this.budget); }
+    asText(value) {
+        if (value.kind === "string" || value.kind === "numeric")
+            return value.text;
+        if (value.kind === "unset")
+            return "";
+        return text(value, text(this.getScalar("CONVFMT"), undefined, this.budget), this.budget);
+    }
     varText(name) { return this.asText(this.getScalar(name)); }
     retainName(path) {
         this.context.signal.throwIfAborted();
@@ -88,8 +94,8 @@ export class AwkRuntime {
     storeScalar(store, name, value) {
         if (value.kind === "string" || value.kind === "numeric")
             this.budget.check(value.text);
-        const owned = this.retention.replace(textSize(store.get(name)), textSize(value), () => ownScalar(value));
-        store.set(name, owned);
+        this.retention.admit(textSize(store.get(name)), textSize(value));
+        store.set(name, ownScalar(value));
     }
     bindArray(store, name, array) {
         let allocation = this.arrays.get(array);
@@ -144,14 +150,14 @@ export class AwkRuntime {
         this.budget.check(key);
         if (value.kind === "string" || value.kind === "numeric")
             this.budget.check(value.text);
-        const existing = array.entries.has(key);
+        const existingValue = array.entries.get(key);
+        const existing = existingValue !== undefined || array.entries.has(key);
         if (!existing && this.entries >= (this.budget.options.maxArrayEntries ?? Infinity))
             throw new ProgramError("array entry limit exceeded");
-        const previous = textSize(array.entries.get(key)), next = textSize(value) + (existing ? 0 : key.length);
-        const owned = this.retention.replace(previous, next, () => ({
-            key: existing ? key : Buffer.from(key, "latin1").toString("latin1"), value: ownScalar(value),
-        }));
-        array.entries.set(owned.key, owned.value);
+        const previous = textSize(existingValue), next = textSize(value) + (existing ? 0 : key.length);
+        this.retention.admit(previous, next);
+        const ownedKey = existing || key.length < 13 ? key : Buffer.from(key, "latin1").toString("latin1");
+        array.entries.set(ownedKey, ownScalar(value));
         this.arrays.get(array).bytes += next - previous;
         if (!existing)
             this.entries++;
@@ -167,6 +173,50 @@ export class AwkRuntime {
         return pattern;
     }
     async regex(expression) { return expression.kind === "regex" ? expression.pattern : this.pattern(this.asText(await this.scalarExpression(expression))); }
+    splitSync(value, separator, paragraph) {
+        if (!paragraph && value.length < 256 && (separator === " " || separator.length === 1)) {
+            this.budget.step(value.length);
+            const maxFields = this.budget.options.maxFields ?? Infinity;
+            const parts = [];
+            if (separator === " ") {
+                let start = -1;
+                for (let index = 0; index < value.length; index++) {
+                    const ch = value.charCodeAt(index);
+                    if (ch === 32 || ch === 9 || ch === 10) {
+                        if (start >= 0) {
+                            if (parts.length >= maxFields)
+                                throw new ProgramError("field count limit exceeded");
+                            parts.push(inputValue(value.slice(start, index)));
+                            start = -1;
+                        }
+                    }
+                    else if (start < 0)
+                        start = index;
+                }
+                if (start >= 0) {
+                    if (parts.length >= maxFields)
+                        throw new ProgramError("field count limit exceeded");
+                    parts.push(inputValue(value.slice(start, value.length)));
+                }
+                return parts;
+            }
+            if (value !== "") {
+                let start = 0;
+                let idx;
+                while ((idx = value.indexOf(separator, start)) >= 0) {
+                    if (parts.length >= maxFields)
+                        throw new ProgramError("field count limit exceeded");
+                    parts.push(inputValue(value.slice(start, idx)));
+                    start = idx + 1;
+                }
+                if (parts.length >= maxFields)
+                    throw new ProgramError("field count limit exceeded");
+                parts.push(inputValue(value.slice(start, value.length)));
+            }
+            return parts;
+        }
+        return this.split(value, separator, paragraph);
+    }
     async split(value, separator, paragraph = false) {
         // Admit the byte scan/copy before building fields; regex matching charges its own work.
         this.budget.step(value.length);
@@ -180,7 +230,7 @@ export class AwkRuntime {
             let start = -1;
             for (let index = 0; index < value.length; index++) {
                 if (index % 256 === 0)
-                    await this.budget.checkpoint();
+                    await this.budget.checkpointSync();
                 if (" \t\n".includes(value[index])) {
                     if (start >= 0) {
                         append(start, index);
@@ -198,15 +248,30 @@ export class AwkRuntime {
                 throw new ProgramError("field count limit exceeded");
             for (let index = 0; index < value.length; index++) {
                 if (index % 256 === 0)
-                    await this.budget.checkpoint();
+                    await this.budget.checkpointSync();
                 append(index, index + 1);
             }
         }
         else if (typeof separator === "string" && separator.length === 1) {
+            if (!paragraph && value.length < 256) {
+                if (value !== "") {
+                    let start = 0;
+                    let idx;
+                    while ((idx = value.indexOf(separator, start)) >= 0) {
+                        append(start, idx);
+                        start = idx + 1;
+                    }
+                    append(start, value.length);
+                }
+                return parts;
+            }
             let start = 0;
             for (let index = 0; index < value.length; index++) {
-                if (index % 256 === 0)
-                    await this.budget.checkpoint();
+                if (index > 0 && index % 256 === 0) {
+                    const p = this.budget.checkpointSync();
+                    if (p)
+                        await p;
+                }
                 if (value[index] === separator || paragraph && value[index] === "\n") {
                     append(start, index);
                     start = index + 1;
@@ -221,7 +286,7 @@ export class AwkRuntime {
                 if (paragraph)
                     for (let index = start; index < end; index++) {
                         if (index % 256 === 0)
-                            await this.budget.checkpoint();
+                            await this.budget.checkpointSync();
                         if (value[index] === "\n") {
                             append(start, index);
                             start = index + 1;
@@ -232,7 +297,7 @@ export class AwkRuntime {
             let consumed = 0;
             let search = 0;
             while (search <= value.length) {
-                await this.budget.checkpoint();
+                await this.budget.checkpointSync();
                 const match = await matcher.find(value, this.budget, search);
                 if (!match)
                     break;
@@ -249,10 +314,17 @@ export class AwkRuntime {
         }
         return parts;
     }
-    async setRecord(record, value = inputValue(record)) {
+    setRecordSync(record, value = inputValue(record)) {
         this.budget.check(record);
-        const fields = await this.split(record, this.varText("FS"), this.varText("RS") === "");
-        this.replaceRecord(record, fields, value);
+        const fields = this.splitSync(record, this.varText("FS"), this.varText("RS") === "");
+        if (!(fields instanceof Promise)) {
+            this.replaceRecord(record, fields, value);
+            return;
+        }
+        return fields.then(resolved => { this.replaceRecord(record, resolved, value); });
+    }
+    async setRecord(record, value = inputValue(record)) {
+        await this.setRecordSync(record, value);
     }
     replaceRecord(record, fields, value = string(record)) {
         let fieldBytes = 0;
@@ -261,12 +333,9 @@ export class AwkRuntime {
                 this.budget.check(field.text);
             fieldBytes += textSize(field);
         }
-        const owned = this.retention.replace(this.record.length + this.fieldBytes, record.length + fieldBytes, () => ({
-            record: Buffer.from(record, "latin1").toString("latin1"),
-            fields: fields.map((field, index) => field === this.fields[index] ? field : ownScalar(field)),
-        }));
-        this.record = owned.record;
-        this.fields = owned.fields;
+        this.retention.admit(this.record.length + this.fieldBytes, record.length + fieldBytes);
+        this.record = record;
+        this.fields = fields;
         this.fieldBytes = fieldBytes;
         this.recordValue = value.kind === "string" || value.kind === "numeric" ? { ...value, text: this.record } : value;
         this.variables.set("NF", numeric(fields.length));
@@ -294,7 +363,21 @@ export class AwkRuntime {
         const record = this.join(fields.map(value => this.asText(value)), this.varText("OFS"));
         this.replaceRecord(record, fields);
     }
-    async key(items) {
+    key(items) {
+        if (items.length === 1) {
+            const first = this.scalarExpression(items[0]);
+            if (!(first instanceof Promise)) {
+                const k = this.asText(first);
+                this.budget.step(2);
+                if (k.length > this.budget.maxBufferBytes)
+                    throw new ProgramError("text buffer limit exceeded");
+                this.budget.step(k.length);
+                return k;
+            }
+        }
+        return this.keySlow(items);
+    }
+    async keySlow(items) {
         const pieces = [];
         for (const item of items)
             pieces.push(this.asText(await this.scalarExpression(item)));
@@ -336,76 +419,237 @@ export class AwkRuntime {
             throw new ProgramError("non-finite arithmetic result");
         return result;
     }
-    async scalarExpression(expression) { return scalar(await this.evaluate(expression)); }
-    async evaluate(expression) {
+    scalarExpression(expression) {
+        const val = this.evaluate(expression);
+        return val instanceof Promise ? val.then(scalar) : scalar(val);
+    }
+    evaluate(expression) {
         this.budget.step();
         switch (expression.kind) {
             case "number": return numeric(expression.value);
             case "string": return string(expression.value);
-            case "regex": return numeric((await expression.pattern.find(this.record, this.budget)) ? 1 : 0);
+            case "regex": return expression.pattern.find(this.record, this.budget).then(m => numeric(m ? 1 : 0));
             case "variable": return this.get(expression.name);
-            case "field":
-            case "array": return (await this.reference(expression)).get();
+            case "field": {
+                const idxVal = this.scalarExpression(expression.index);
+                if (!(idxVal instanceof Promise)) {
+                    const index = Math.trunc(number(idxVal));
+                    if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity))
+                        throw new ProgramError("invalid or excessive field index");
+                    return index === 0 ? this.recordValue : this.fields[index - 1] ?? unset;
+                }
+                return idxVal.then(resolved => {
+                    const index = Math.trunc(number(resolved));
+                    if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity))
+                        throw new ProgramError("invalid or excessive field index");
+                    return index === 0 ? this.recordValue : this.fields[index - 1] ?? unset;
+                });
+            }
+            case "array": {
+                const array = this.array(expression.name);
+                const k = this.key(expression.indexes);
+                if (!(k instanceof Promise)) {
+                    let existing = array.entries.get(k);
+                    if (existing === undefined && !array.entries.has(k)) {
+                        this.arraySet(array, k, unset);
+                        existing = unset;
+                    }
+                    return existing;
+                }
+                return k.then(resolvedKey => {
+                    let existing = array.entries.get(resolvedKey);
+                    if (existing === undefined && !array.entries.has(resolvedKey)) {
+                        this.arraySet(array, resolvedKey, unset);
+                        existing = unset;
+                    }
+                    return existing;
+                });
+            }
             case "getline": return this.getline(expression);
             case "tuple": throw new ProgramError("tuple is only valid as an array membership key");
-            case "conditional": return this.evaluate(truth(await this.scalarExpression(expression.condition)) ? expression.yes : expression.no);
+            case "conditional": {
+                const cond = this.scalarExpression(expression.condition);
+                return cond instanceof Promise ? cond.then(c => this.evaluate(truth(c) ? expression.yes : expression.no)) : this.evaluate(truth(cond) ? expression.yes : expression.no);
+            }
             case "unary": {
                 if (expression.operator === "++" || expression.operator === "--") {
-                    const reference = await this.reference(expression.operand);
-                    const previous = number(scalar(reference.get()));
-                    const next = previous + (expression.operator === "++" ? 1 : -1);
-                    await reference.set(numeric(next));
-                    return numeric(expression.postfix ? previous : next);
+                    if (expression.operand.kind === "variable") {
+                        const name = expression.operand.name;
+                        const previous = number(scalar(this.get(name)));
+                        const next = previous + (expression.operator === "++" ? 1 : -1);
+                        this.set(name, numeric(next));
+                        return numeric(expression.postfix ? previous : next);
+                    }
+                    if (expression.operand.kind === "array") {
+                        const array = this.array(expression.operand.name);
+                        const k = this.key(expression.operand.indexes);
+                        if (!(k instanceof Promise)) {
+                            let current = array.entries.get(k);
+                            if (current === undefined && !array.entries.has(k)) {
+                                this.arraySet(array, k, unset);
+                                current = unset;
+                            }
+                            const previous = number(scalar(current));
+                            const next = previous + (expression.operator === "++" ? 1 : -1);
+                            this.arraySet(array, k, numeric(next));
+                            return numeric(expression.postfix ? previous : next);
+                        }
+                        return k.then(resolvedKey => {
+                            let current = array.entries.get(resolvedKey);
+                            if (current === undefined && !array.entries.has(resolvedKey)) {
+                                this.arraySet(array, resolvedKey, unset);
+                                current = unset;
+                            }
+                            const previous = number(scalar(current));
+                            const next = previous + (expression.operator === "++" ? 1 : -1);
+                            this.arraySet(array, resolvedKey, numeric(next));
+                            return numeric(expression.postfix ? previous : next);
+                        });
+                    }
+                    return this.evaluateUnarySlow(expression);
                 }
-                const operand = await this.scalarExpression(expression.operand);
-                return numeric(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
+                const operand = this.scalarExpression(expression.operand);
+                if (!(operand instanceof Promise)) {
+                    return numeric(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
+                }
+                return operand.then(op => numeric(expression.operator === "!" ? truth(op) ? 0 : 1 : expression.operator === "-" ? -number(op) : number(op)));
             }
             case "binary": {
                 const operator = expression.operator;
-                if (["=", "+=", "-=", "*=", "/=", "%=", "^="].includes(operator)) {
-                    const reference = await this.reference(expression.left);
-                    const previous = operator === "=" ? unset : scalar(reference.get());
-                    let value = await this.scalarExpression(expression.right);
-                    if (operator !== "=")
-                        value = numeric(this.arithmetic(operator[0], number(previous), number(value)));
-                    await reference.set(value);
-                    return value;
+                if (operator === "=" || operator === "+=" || operator === "-=" || operator === "*=" || operator === "/=" || operator === "%=" || operator === "^=") {
+                    if (expression.left.kind === "variable") {
+                        const name = expression.left.name;
+                        const previous = operator === "=" ? unset : scalar(this.get(name));
+                        const rightVal = this.scalarExpression(expression.right);
+                        if (!(rightVal instanceof Promise)) {
+                            const value = operator === "=" ? rightVal : numeric(this.arithmetic(operator[0], number(previous), number(rightVal)));
+                            this.set(name, value);
+                            return value;
+                        }
+                        return rightVal.then(resolved => {
+                            const value = operator === "=" ? resolved : numeric(this.arithmetic(operator[0], number(previous), number(resolved)));
+                            this.set(name, value);
+                            return value;
+                        });
+                    }
+                    else if (expression.left.kind === "array") {
+                        const array = this.array(expression.left.name);
+                        const k = this.key(expression.left.indexes);
+                        if (!(k instanceof Promise)) {
+                            let current = operator === "=" ? unset : array.entries.get(k);
+                            if (operator !== "=" && current === undefined && !array.entries.has(k)) {
+                                this.arraySet(array, k, unset);
+                                current = unset;
+                            }
+                            const previous = scalar(current);
+                            const rightVal = this.scalarExpression(expression.right);
+                            if (!(rightVal instanceof Promise)) {
+                                const value = operator === "=" ? rightVal : numeric(this.arithmetic(operator[0], number(previous), number(rightVal)));
+                                this.arraySet(array, k, value);
+                                return value;
+                            }
+                            return rightVal.then(resolved => {
+                                const value = operator === "=" ? resolved : numeric(this.arithmetic(operator[0], number(previous), number(resolved)));
+                                this.arraySet(array, k, value);
+                                return value;
+                            });
+                        }
+                        return k.then(async (resolvedKey) => {
+                            let current = operator === "=" ? unset : array.entries.get(resolvedKey);
+                            if (operator !== "=" && current === undefined && !array.entries.has(resolvedKey)) {
+                                this.arraySet(array, resolvedKey, unset);
+                                current = unset;
+                            }
+                            const previous = scalar(current);
+                            const resolved = await this.scalarExpression(expression.right);
+                            const value = operator === "=" ? resolved : numeric(this.arithmetic(operator[0], number(previous), number(resolved)));
+                            this.arraySet(array, resolvedKey, value);
+                            return value;
+                        });
+                    }
+                    return this.evaluateBinarySlow(expression);
                 }
-                if (operator === "in") {
-                    const array = this.array(expression.right.name);
-                    const key = expression.left.kind === "tuple" ? await this.key(expression.left.items) : this.asText(await this.scalarExpression(expression.left));
-                    return numeric(array.entries.has(key) ? 1 : 0);
+                if (operator === "in" || operator === "~" || operator === "!~") {
+                    return this.evaluateBinarySlow(expression);
                 }
-                const left = await this.scalarExpression(expression.left);
+                const left = this.scalarExpression(expression.left);
+                if (left instanceof Promise)
+                    return this.evaluateBinaryWithLeftPromise(expression, left);
                 if (operator === "&&" && !truth(left))
                     return numeric(0);
                 if (operator === "||" && truth(left))
                     return numeric(1);
-                if (operator === "~" || operator === "!~") {
-                    const matched = (await (await this.regex(expression.right)).find(this.asText(left), this.budget)) !== undefined;
-                    return numeric((operator === "~" ? matched : !matched) ? 1 : 0);
-                }
-                const right = await this.scalarExpression(expression.right);
-                if (operator === "&&" || operator === "||")
-                    return numeric(truth(right) ? 1 : 0);
-                if (operator === "concat") {
-                    const leftText = this.asText(left);
-                    const rightText = this.asText(right);
-                    this.budget.step(0);
-                    if (rightText.length > this.budget.maxBufferBytes - leftText.length)
-                        throw new ProgramError("text buffer limit exceeded");
-                    this.budget.step(leftText.length + rightText.length);
-                    return string(leftText + rightText);
-                }
-                if (["==", "!=", "<", "<=", ">", ">="].includes(operator)) {
-                    const order = compare(left, right, this.varText("CONVFMT"), this.budget);
-                    return numeric((operator === "==" ? order === 0 : operator === "!=" ? order !== 0 : operator === "<" ? order < 0 : operator === "<=" ? order <= 0 : operator === ">" ? order > 0 : order >= 0) ? 1 : 0);
-                }
-                return numeric(this.arithmetic(operator, number(left), number(right)));
+                const right = this.scalarExpression(expression.right);
+                if (right instanceof Promise)
+                    return right.then(r => this.evaluateBinarySyncOperands(operator, left, r));
+                return this.evaluateBinarySyncOperands(operator, left, right);
             }
             case "call": return this.call(expression.name, expression.args);
         }
     }
+    evaluateBinarySyncOperands(operator, left, right) {
+        if (operator === "&&" || operator === "||")
+            return numeric(truth(right) ? 1 : 0);
+        if (operator === "concat") {
+            const leftText = this.asText(left);
+            const rightText = this.asText(right);
+            this.budget.step(0);
+            if (rightText.length > this.budget.maxBufferBytes - leftText.length)
+                throw new ProgramError("text buffer limit exceeded");
+            this.budget.step(leftText.length + rightText.length);
+            return string(leftText + rightText);
+        }
+        if (operator === "==" || operator === "!=" || operator === "<" || operator === "<=" || operator === ">" || operator === ">=") {
+            const order = compare(left, right, this.varText("CONVFMT"), this.budget);
+            return numeric((operator === "==" ? order === 0 : operator === "!=" ? order !== 0 : operator === "<" ? order < 0 : operator === "<=" ? order <= 0 : operator === ">" ? order > 0 : order >= 0) ? 1 : 0);
+        }
+        return numeric(this.arithmetic(operator, number(left), number(right)));
+    }
+    async evaluateBinaryWithLeftPromise(expression, leftPromise) {
+        const operator = expression.operator;
+        const left = await leftPromise;
+        if (operator === "&&" && !truth(left))
+            return numeric(0);
+        if (operator === "||" && truth(left))
+            return numeric(1);
+        const right = await this.scalarExpression(expression.right);
+        return this.evaluateBinarySyncOperands(operator, left, right);
+    }
+    async evaluateUnarySlow(expression) {
+        if (expression.operator === "++" || expression.operator === "--") {
+            const reference = await this.reference(expression.operand);
+            const previous = number(scalar(reference.get()));
+            const next = previous + (expression.operator === "++" ? 1 : -1);
+            await reference.set(numeric(next));
+            return numeric(expression.postfix ? previous : next);
+        }
+        const operand = await this.scalarExpression(expression.operand);
+        return numeric(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
+    }
+    async evaluateBinarySlow(expression) {
+        const operator = expression.operator;
+        if (["=", "+=", "-=", "*=", "/=", "%=", "^="].includes(operator)) {
+            const reference = await this.reference(expression.left);
+            const previous = operator === "=" ? unset : scalar(reference.get());
+            let value = await this.scalarExpression(expression.right);
+            if (operator !== "=")
+                value = numeric(this.arithmetic(operator[0], number(previous), number(value)));
+            await reference.set(value);
+            return value;
+        }
+        if (operator === "in") {
+            const array = this.array(expression.right.name);
+            const key = expression.left.kind === "tuple" ? await this.key(expression.left.items) : this.asText(await this.scalarExpression(expression.left));
+            return numeric(array.entries.has(key) ? 1 : 0);
+        }
+        const left = await this.scalarExpression(expression.left);
+        if (operator === "~" || operator === "!~") {
+            const matched = (await (await this.regex(expression.right)).find(this.asText(left), this.budget)) !== undefined;
+            return numeric((operator === "~" ? matched : !matched) ? 1 : 0);
+        }
+        const right = await this.scalarExpression(expression.right);
+        return this.evaluateBinarySyncOperands(operator, left, right);
+    }
     async getline(expression) {
         if (!expression.file) {
             const record = await this.readMainRecord();
@@ -444,7 +688,7 @@ export class AwkRuntime {
                     yield* context.stdin;
                 else {
                     budget.step();
-                    await budget.checkpoint();
+                    await budget.checkpointSync();
                     const capabilities = await context.fs.capabilitiesFor?.(name, { signal: context.signal }) ?? context.fs.capabilities;
                     context.signal.throwIfAborted();
                     if (context.fs.readStream && capabilities.streamingRead !== false)
@@ -626,11 +870,52 @@ export class AwkRuntime {
             throw new ProgramError(`invalid mathematical result in '${name}'`);
         return numeric(result);
     }
+    executeSync(statement) {
+        if (!this.inspection) {
+            const p = this.budget.checkpointSync();
+            if (!p) {
+                if (statement.kind === "expression") {
+                    this.budget.step();
+                    const val = this.evaluate(statement.expression);
+                    return val instanceof Promise ? val.then(() => undefined) : undefined;
+                }
+                if (statement.kind === "block") {
+                    this.budget.step();
+                    for (let i = 0; i < statement.body.length; i++) {
+                        const res = this.executeSync(statement.body[i]);
+                        if (res instanceof Promise) {
+                            return this.executeBlockRemainder(statement.body, i + 1, res);
+                        }
+                    }
+                    return undefined;
+                }
+                if (statement.kind === "if") {
+                    this.budget.step();
+                    const cond = this.scalarExpression(statement.condition);
+                    if (!(cond instanceof Promise)) {
+                        const branch = truth(cond) ? statement.yes : statement.no;
+                        return branch ? this.executeSync(branch) : undefined;
+                    }
+                }
+            }
+        }
+        return this.execute(statement);
+    }
+    async executeBlockRemainder(body, startIndex, current) {
+        await current;
+        for (let i = startIndex; i < body.length; i++) {
+            const res = this.executeSync(body[i]);
+            if (res instanceof Promise)
+                await res;
+        }
+    }
     async execute(statement) {
         this.budget.step();
         if (this.inspection)
             await this.inspection.observe(statement, this.phase);
-        await this.budget.checkpoint();
+        const p = this.budget.checkpointSync();
+        if (p)
+            await p;
         switch (statement.kind) {
             case "block":
                 for (const child of statement.body)
@@ -796,6 +1081,47 @@ export class AwkRuntime {
         return status;
     }
     async readMainRecord() {
+        const syncRes = this.readMainRecordSync();
+        return syncRes instanceof Promise ? await syncRes : syncRes;
+    }
+    incrementCounter(name) {
+        const current = this.variables.get(name);
+        if (current && !(current instanceof AwkArray) && current.kind === "number" && !this.frames.at(-1)?.has(name)) {
+            this.retention.admit(0, 0);
+            this.variables.set(name, numeric(current.number + 1));
+            return;
+        }
+        this.set(name, numeric(number(this.getScalar(name)) + 1));
+    }
+    readMainRecordSync() {
+        if (this.mainReader) {
+            this.budget.step();
+            const record = this.mainReader.readSync(this.varText("RS"));
+            if (typeof record === "string") {
+                this.incrementCounter("NR");
+                this.incrementCounter("FNR");
+                return record;
+            }
+            if (record instanceof Promise) {
+                return record.then(resolved => {
+                    if (resolved !== undefined) {
+                        this.incrementCounter("NR");
+                        this.incrementCounter("FNR");
+                        return resolved;
+                    }
+                    return this.readMainRecordSlowAfterEof();
+                });
+            }
+            return this.readMainRecordSlowAfterEof();
+        }
+        return this.readMainRecordSlow();
+    }
+    async readMainRecordSlowAfterEof() {
+        await this.mainReader?.close();
+        this.mainReader = undefined;
+        return this.readMainRecordSlow();
+    }
+    async readMainRecordSlow() {
         while (true) {
             this.budget.step();
             if (!this.mainReader) {
@@ -805,7 +1131,9 @@ export class AwkRuntime {
                     const argumentOptions = this.budget.options;
                     if (this.argument > (argumentOptions?.maxArguments ?? Infinity))
                         throw new ProgramError("argument count limit exceeded");
-                    await this.budget.checkpoint();
+                    const p = this.budget.checkpointSync();
+                    if (p)
+                        await p;
                     const next = this.asText(this.array("ARGV").entries.get(String(this.argument++)) ?? unset);
                     if (!next)
                         continue;
@@ -833,8 +1161,8 @@ export class AwkRuntime {
                 this.mainReader = undefined;
                 continue;
             }
-            this.set("NR", numeric(number(this.getScalar("NR")) + 1));
-            this.set("FNR", numeric(number(this.getScalar("FNR")) + 1));
+            this.incrementCounter("NR");
+            this.incrementCounter("FNR");
             return record;
         }
     }
@@ -857,23 +1185,33 @@ export class AwkRuntime {
         if (!stopped && (this.program.rules.length || this.program.end.length))
             while (true) {
                 this.budget.step();
-                const record = await this.readMainRecord();
+                const recOrPromise = this.readMainRecordSync();
+                const record = recOrPromise instanceof Promise ? await recOrPromise : recOrPromise;
                 if (record === undefined)
                     break;
-                await this.setRecord(record);
+                const setRecPromise = this.setRecordSync(record);
+                if (setRecPromise instanceof Promise)
+                    await setRecPromise;
                 try {
                     for (let index = 0; index < this.program.rules.length; index++) {
                         const rule = this.program.rules[index];
-                        const selected = !rule.pattern || ranges.has(index) || truth(await this.scalarExpression(rule.pattern));
+                        let selected = !rule.pattern || ranges.has(index);
+                        if (!selected) {
+                            const patVal = this.scalarExpression(rule.pattern);
+                            selected = truth(patVal instanceof Promise ? await patVal : patVal);
+                        }
                         if (!selected)
                             continue;
                         if (rule.end) {
-                            if (truth(await this.scalarExpression(rule.end)))
+                            const endVal = this.scalarExpression(rule.end);
+                            if (truth(endVal instanceof Promise ? await endVal : endVal))
                                 ranges.delete(index);
                             else
                                 ranges.add(index);
                         }
-                        await this.execute(rule.action);
+                        const execRes = this.executeSync(rule.action);
+                        if (execRes instanceof Promise)
+                            await execRes;
                     }
                 }
                 catch (error) {