parseman 0.47.1 → 0.48.1

package/src/table/child-slots.ts

@@ -4,6 +4,7 @@ import {
   OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_LIVE, OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT,
   OP_PEEK, OP_REJECT, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX, OP_RX_TRACK, OP_SCAN,
   OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_WITHCTX, OP_XFORM,
+  OP_LEX_BODY, OP_LEX_PROGRAM,
 } from './ops.ts'
 
 /**
@@ -41,7 +42,7 @@ export function childSlots(code: ArrayLike<number>, ip: number, out: number[]):
     // structure is a closure, so there is no successor row to reach.
     case OP_LIT: case OP_RX: case OP_LIT_TRACK: case OP_RX_TRACK: case OP_EMPTY:
     case OP_SCAN: case OP_LIT_CI: case OP_LIT_CI_TRACK:
-    case OP_GUARD: case OP_ADJ: case OP_LIVE:
+    case OP_GUARD: case OP_ADJ: case OP_LIVE: case OP_LEX_BODY: case OP_LEX_PROGRAM:
       return true
 
     // Single child at `ip + 1`. `OP_COV` is a wrapper on the same footing as the

package/src/table/compile-rule-map.ts

@@ -3,13 +3,21 @@ import { hasDirectBuildDef } from '../analysis/commitment.ts'
 import type { HostMode } from '../cst/host-mode.ts'
 import { collectGrammarReflection, type GrammarReflection } from '../cst/reflection.ts'
 import { encodeTableProgram, type TableSettings } from './encode.ts'
-import { emitTableExpression } from './emit.ts'
+import { defaultAssemblyCfgs, emitTableExpression } from './emit.ts'
 import { tableRules } from './assemble.ts'
 import { closureArtifact } from './program.ts'
 import type { TableProgram, TableRule } from './program.ts'
 import { buildGrammarPlan, type GrammarCoverageDefinition } from '../compiler/grammar-coverage-ids.ts'
 import { runDuplicationDiagnosticRules, type DuplicationOption } from './duplication-hook.ts'
 
+/**
+ * Static assembly has a fixed source cost that tiny grammars cannot amortize.
+ * The canonical size probe's composeLeaf is 62 words and grows by ~12 kB with
+ * a factory; the shipping Jess leaves are 6,365/10,892 words. Keep the policy
+ * between those measured populations so small artifacts retain table density.
+ */
+const DEFAULT_PRECOMPILE_MIN_WORDS = 1_024
+
 /**
  * `compileRuleMap()` FOR THE TABLE LOWERING — the counterpart that did not exist.
  *
@@ -100,7 +108,10 @@ export type CompiledRuleMapTable = {
   /** The expression that replaces the whole `rules(factory)` call. */
   replacement: string
   /** Re-emit the same table call with construction-time artifact metadata. */
-  replacementWithMetadata(metadataSource: string): string
+  replacementWithMetadata(
+    metadataSource: string,
+    options?: { readonly precompileDefault?: boolean },
+  ): string
   hostMode: HostMode
   hostBranchElided: boolean
   reflection: GrammarReflection
@@ -307,10 +318,17 @@ export function compileRuleMap(
     )
   }
 
-  const replacementWithMetadata = (metadataSource?: string): string => emitTableExpression(artifact, {
+  const replacementWithMetadata = (
+    metadataSource?: string,
+    options: { readonly precompileDefault?: boolean } = {},
+  ): string => emitTableExpression(artifact, {
     entry: null,
     runtimeRef: opts.runtimeRef ?? 'tableRules',
     fnSources: sources as string[],
+    ...(options.precompileDefault === true && hostMode === 'ast' && prog.lines !== 1
+      && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS
+      ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) }
+      : {}),
     ...(metadataSource === undefined ? {} : { metadataSource }),
   })
   const replacement = replacementWithMetadata()