@barefootjs/mojolicious 0.17.0 → 0.18.0

package/src/adapter/mojo-adapter.ts

@@ -26,6 +26,7 @@ import type {
   CompilerError,
   TypeInfo,
   TemplatePrimitiveRegistry,
+  LoopBindingPathSegment,
 } from '@barefootjs/jsx'
 import {
   BaseAdapter,
@@ -49,14 +50,15 @@ import {
   parseRecordIndexAccess,
   extractArrowBodyExpression,
   collectContextConsumers,
-  isLowerableObjectRestDestructure,
   type ContextConsumer,
   collectModuleStringConsts,
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
   prepareLoweringMatchers,
   queryHrefArgs,
+  isValidHelperId,
   sortComparatorFromArrow,
+  isLowerableLoopDestructure,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher } from '@barefootjs/jsx'
@@ -94,6 +96,43 @@ import {
 export type { MojoAdapterOptions } from './lib/types.ts'
 import type { MojoAdapterOptions } from './lib/types.ts'
 
+/**
+ * Build a Perl accessor expression for a `.map()` destructure binding's
+ * structured `segments` path (#2087 Phase B), walking `field` (`->{key}`,
+ * quoted with `perlHashKey`'s convention when `!isIdent`) / `index`
+ * (`->[N]`) steps onto `base`. Never string-parses `LoopParamBinding.path` —
+ * see the repo-wide rule against regex-parsing JS/TS-derived syntax.
+ *
+ * Used both for a fixed binding's FULL accessor (`base` = `$__bf_item`,
+ * `segments` = the whole path) and a rest binding's PARENT-prefix accessor
+ * (`segments` may be empty, at the loop root, in which case this returns
+ * `base` unchanged) — see `LoopParamBinding.segments` jsdoc for which case
+ * a binding is in.
+ */
+function perlSegmentAccessor(base: string, segments: readonly LoopBindingPathSegment[]): string {
+  let expr = base
+  for (const seg of segments) {
+    expr +=
+      seg.kind === 'field'
+        ? `->{${seg.isIdent ? seg.key : perlHashKey(seg.key)}}`
+        : `->[${seg.index}]`
+  }
+  return expr
+}
+
+/**
+ * Quote a string as a Perl single-quoted literal (backslash first, then the
+ * quote, so the escape doesn't double up). Unlike `perlHashKey` — which
+ * intentionally leaves an identifier-safe name as a bareword for `->{key}` /
+ * `key => val` hash-key position — a plain list element (`bf->omit($x, [id,
+ * title])`) is NOT hash-key position: an unquoted bareword there is a sub
+ * call under `use strict subs`, so every object-rest exclude key needs an
+ * unconditional string literal.
+ */
+function perlStringLiteral(s: string): string {
+  return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+}
+
 export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRenderCtx> {
   name = 'mojolicious'
   extension = '.html.ep'
@@ -695,44 +734,89 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   // ===========================================================================
 
   renderLoop(loop: IRLoop): string {
-    // Client-only loops: skip SSR rendering entirely
-    if (loop.clientOnly) return ''
-
-    // An array/object-destructure loop param (`([emoji, users]) => ...`
-    // or `({ name, age }) => ...`) lowers to invalid Perl — the adapter
-    // would otherwise emit `% my $[emoji, users] = $entries->[$_i];`,
-    // which is a parse error. Surface this at build time (#1266)
-    // instead of shipping the broken template line for the user to
-    // discover at request time.
+    // clientOnly loops must not render items at SSR time, but must still emit
+    // the `loop:`/`/loop:` boundary marker pair (Hono and Go parity) so the
+    // client runtime's mapArray() can locate the insertion anchor when
+    // hydrating the array. Without the markers, mapArray() resolves
+    // anchor = null and appends after sibling markers (#872). The marker id
+    // disambiguates sibling `.map()` calls under the same parent (#1087).
+    if (loop.clientOnly) {
+      return `<%== bf->comment("loop:${loop.markerId}") %><%== bf->comment("/loop:${loop.markerId}") %>`
+    }
+
+    // A `.map()` destructure loop param (`([k, v]) => ...` / `({ id, user: {
+    // name } }) => ...` / `({ id, ...rest }) => ...`) lowers to a Perl `my`
+    // local per binding, walking each binding's structured `segments` path
+    // (#2087 Phase B) into a native `->{key}` / `->[N]` accessor off the
+    // per-item var — so the body's `$id` / `$name` / `$rest->{flag}` /
+    // `{...rest}` all resolve natively, at any nesting depth.
     //
     // Check the IR's structured `paramBindings` field rather than
     // string-matching `loop.param`: Phase 1 populates `paramBindings`
     // iff the param is a destructure pattern (array or object); a
     // simple identifier leaves it `undefined`. The structured check is
     // robust to whitespace / formatting variants in the source.
-    // A destructure loop param is lowerable for the object-rest / simple-field
-    // shape (`.map(({ id, title, ...rest }) => …)`, `rest` read via member
-    // access): each binding becomes a Perl `my` local off the per-item var, so
-    // the body's `$id` / `$rest->{flag}` resolve natively. Array-index / nested
-    // / rest-spread shapes still can't unpack into scalar `my`s → BF104. (#1310)
+    //
+    // `isLowerableLoopDestructure` (#2087) still refuses: an object-rest
+    // binding used any way other than member access (`rest.flag`) or a
+    // `{...rest}` spread onto an intrinsic element (that needs the actual
+    // residual *object*, which isn't always safe to materialize — see the
+    // gate's own jsdoc for the full list); a `.filter().map(destructure)`
+    // chain (the filter-param rewrite is out of scope here); and a
+    // computed property key (`{ [k]: v }`, refused earlier as BF025).
     const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0)
-    const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop)
+    const supportableDestructure = destructure && isLowerableLoopDestructure(loop)
     if (destructure && !supportableDestructure) {
       this.errors.push({
         code: 'BF104',
         severity: 'error',
-        message: `Loop callback uses an array/object destructure pattern (\`${loop.param}\`) that the Mojo adapter cannot lower — Perl scalar bindings can't unpack a tuple in a single \`my\` declaration.`,
+        message: `Loop callback uses a destructure pattern (\`${loop.param}\`) that the Mojo adapter cannot lower — see the diagnostic detail for the specific shape.`,
         loc: loop.loc ?? { file: this.componentName + '.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
         suggestion: {
           message:
             `Options:\n` +
-            `  1. Rename the parameter to a single name and access tuple elements with index syntax in the body (e.g. \`entry => entry->[0]\` instead of \`([k, v]) => ...\`).\n` +
-            `  2. Mark the loop position as @client-only so the destructure runs in JS on the client.\n` +
-            `  3. Move the loop into a primitive that the adapter registers explicitly.`,
+            `  1. If this is an object-rest binding (\`{ ...rest }\`), only reading \`rest.field\` or spreading \`{...rest}\` onto an intrinsic element lowers — other uses (passing \`rest\` to a function, rendering it as text) need the client runtime.\n` +
+            `  2. If this is chained \`.filter().map(({ ... }) => ...)\`, hoist the destructure into a variable inside the callback body instead.\n` +
+            `  3. Mark the loop position as @client-only so the destructure runs in JS on the client.\n` +
+            `  4. Move the loop into a primitive that the adapter registers explicitly.`,
         },
       })
     }
 
+    // A `.map()` loop whose array is a bare identifier bound to a
+    // FUNCTION-scope local const with a non-statically-evaluable initializer
+    // that reads props/signals (e.g. `const entries =
+    // Object.entries(props.x ?? {}).filter(...)`) can't render correctly.
+    // Module-scope consts (`isModule`, e.g. `const payments = [...]` at the
+    // top of the file) are a DIFFERENT, already-working case handled
+    // elsewhere. Function-scope locals get no per-render stash slot — this
+    // adapter's only "elsewhere" for a local const is inlining its value at
+    // the use site (`resolveLiteralConst`'s numeric/single-quoted-string fast
+    // path, or a static-record-literal lookup), never binding one as a `my`
+    // template local. Left unchecked, `% for my $_i (0..$#{$entries}) {`
+    // over an undeclared `$entries` faults under `use strict` at request
+    // time instead of failing loudly at build time. Pre-existing, general
+    // limitation, orthogonal to #2087's destructure-binding work — newly
+    // reachable in this adapter's test corpus only because the widened
+    // destructure gate (#2087 Phase A/B) no longer refuses this fixture's
+    // `([emoji, users]) => ...` param first.
+    const arrayName = loop.array.trim()
+    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+      const arrayConst = (this.localConstants ?? []).find(c => c.name === arrayName)
+      if (arrayConst && !arrayConst.isModule && this.resolveLiteralConst(arrayName) === null) {
+        this.errors.push({
+          code: 'BF101',
+          severity: 'error',
+          message: `Loop array \`${arrayName}\` is a local computed value (\`${arrayConst.value}\`) that the Mojo adapter cannot bind as a template variable — only numeric/string-literal locals inline at their use site.`,
+          loc: loop.loc ?? { file: this.componentName + '.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+          suggestion: {
+            message:
+              'Pre-compute the array server-side and pass it as a prop, or mark the loop position as @client-only so it runs in JS on the client.',
+          },
+        })
+      }
+    }
+
     const rawArray = this.convertExpressionToPerl(loop.array)
     // Apply sort if present (#1448 Tier B): wrap the loop array in the
     // shared sort helper. The same `renderSortEval` / `renderSortMethod`
@@ -837,15 +921,31 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     lines.push(`% for my ${indexVar} (0..$#{${array}}) {`)
     if (loop.iterationShape !== 'keys') {
       if (supportableDestructure) {
-        // Per-item var + one `my` local per binding; `rest` aliases the item
-        // so `$rest->{flag}` resolves (object-rest read via member access).
+        // Per-item var + one `my` local per binding, walking each binding's
+        // `segments` path (#2087 Phase B):
+        //   - fixed (`b.rest` unset): the FULL accessor from `$__bf_item`.
+        //   - array-rest: `bf->slice(parent, from, undef)` — the same
+        //     runtime helper `.slice()` JS-method calls lower to (see
+        //     `array-method.ts`), so the "no end → to length" arithmetic
+        //     stays in one place.
+        //   - object-rest: `bf->omit(parent, [...excluded keys...])` — a
+        //     TRUE residual hashref (not the whole item aliased), so both
+        //     `$rest->{flag}` (member-access use) and `bf->spread_attrs($rest)`
+        //     (spread-onto-element use) see only the non-destructured keys.
+        // `parent` is `$__bf_item` walked through the binding's PARENT-prefix
+        // `segments` (empty at the loop root, per the `LoopParamBinding`
+        // jsdoc) — NOT the same as a fixed binding's full-accessor segments.
         lines.push(`% my $__bf_item = ${array}->[${indexVar}];`)
         for (const b of loop.paramBindings ?? []) {
-          lines.push(
-            b.rest
-              ? `% my $${b.name} = $__bf_item;`
-              : `% my $${b.name} = $__bf_item->{${b.path.slice(1)}};`,
-          )
+          const parent = perlSegmentAccessor('$__bf_item', b.segments ?? [])
+          if (b.rest?.kind === 'object') {
+            const exclude = b.rest.exclude.map(k => perlStringLiteral(k.key)).join(', ')
+            lines.push(`% my $${b.name} = bf->omit(${parent}, [${exclude}]);`)
+          } else if (b.rest?.kind === 'array') {
+            lines.push(`% my $${b.name} = bf->slice(${parent}, ${b.rest.from}, undef);`)
+          } else {
+            lines.push(`% my $${b.name} = ${perlSegmentAccessor('$__bf_item', b.segments ?? [])};`)
+          }
         }
       } else {
         lines.push(`% my $${param} = ${array}->[${indexVar}];`)
@@ -1389,13 +1489,22 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     // now lowering `.length` on a higher-order object to
     // `scalar(@{...})`, the canonical
     // `x.tags.filter(t => t.active).length > 0` shape lowers
-    // cleanly. Predicates that combine a nested higher-order with
-    // something OTHER than `.length` (e.g. `.includes`, `.join`)
-    // still fall back to whatever the emitter produces — most of
-    // those would yield runtime errors in Perl, which is the user's
-    // signal to refactor. Wholesale refusal would also block the
-    // canonical case the issue exists to enable.
-    return emitParsedExpr(expr, new MojoFilterEmitter(param, localVarMap, n => this._isStringValueName(n)))
+    // cleanly, and nested `filter` / `every` / `some` lower to real
+    // inline `grep` forms. The shapes the emitter can only DEGRADE
+    // (nested `find*`, sort / reduce / flatMap inside a predicate)
+    // surface BF101 through the hook below instead of silently
+    // rewriting the predicate (#2038). Wholesale refusal would block
+    // the canonical case #1443 exists to enable, so the gate lives at
+    // the exact degrade points inside `MojoFilterEmitter.callbackMethod`.
+    return emitParsedExpr(
+      expr,
+      new MojoFilterEmitter(
+        param,
+        localVarMap,
+        n => this._isStringValueName(n),
+        (message, reason) => this._recordExprBF101(message, reason),
+      ),
+    )
   }
 
   // ===========================================================================
@@ -1595,6 +1704,17 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
           const argsGo = queryHrefArgs(node, n => this.renderParsedExprToPerl(n))
           return `bf->query(${argsGo.join(', ')})`
         }
+        // Generic `helper-call` (#2069) — the neutral vocabulary's escape
+        // hatch for a userland `LoweringPlugin` that lowers to a single
+        // runtime-helper invocation. `bf-><helper>(args…)` mirrors the
+        // `query` helper's own naming convention exactly: the framework
+        // renders the call, the plugin author registers `<helper>` as a
+        // method on their own Mojolicious `bf` helper object — same
+        // contract as `bf->query` itself, just not built in.
+        if (node?.kind === 'helper-call' && isValidHelperId(node.helper)) {
+          const argsX = node.args.map(a => this.renderParsedExprToPerl(a))
+          return `bf->${node.helper}(${argsX.join(', ')})`
+        }
       }
     }
 

package/src/conformance-pins.ts

@@ -0,0 +1,138 @@
+/**
+ * Per-fixture build-time contracts for shapes the Mojo adapter
+ * intentionally refuses to lower. Owned by this module (not by the
+ * shared fixtures) so adding a new adapter doesn't require touching any
+ * cross-adapter file. Consumed by this package's own conformance test
+ * (as `expectedDiagnostics`) and by `bf compat` (issue-URL attribution).
+ */
+
+import type { ConformancePins } from '@barefootjs/jsx'
+
+export const conformancePins: ConformancePins = {
+  // Sibling-imported child component in a loop body: Mojo emits
+  // a cross-template call that needs separate registration. BF103
+  // makes the requirement loud. (The barefoot CLI passes
+  // `siblingTemplatesRegistered: true` so CLI builds suppress it.)
+  'static-array-children': [{ code: 'BF103', severity: 'error' }],
+  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
+  // call it inside a keyed `.map`. Same BF103 surface as the
+  // synthetic `static-array-children` above — pinned at adapter
+  // level so the shared-component corpus stays adapter-neutral.
+  'todo-app': [{ code: 'BF103', severity: 'error' }],
+  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // `([emoji, users]) => ...` / `([id, t]) => ...` are plain array-index
+  // (tuple) destructures, no rest — #2087 Phase B's `segments`-walking
+  // accessor lowers both to `$__bf_item->[0]` / `$__bf_item->[1]` `my`
+  // locals like any other fixed binding, so BF104 no longer fires for
+  // either fixture. Each now hits a DIFFERENT, pre-existing, orthogonal
+  // gap instead: the loop array (`entries`) is a function-scope local
+  // const with a computed initializer
+  // (`Object.entries(props.x ?? {}).filter(...)`) that the adapter can't
+  // bind as a template variable — see the dedicated `arrayConst` BF101
+  // check in `renderLoop`. This was always true; it was simply
+  // unreachable before because BF104 refused the destructure shape first.
+  'static-array-from-props': [{ code: 'BF101', severity: 'error' }],
+  // Both BF103 (sibling-imported `<Tag>` child component) and the BF101
+  // above fire; BF104 no longer does (see above).
+  'static-array-from-props-with-component': [
+    { code: 'BF103', severity: 'error' },
+    { code: 'BF101', severity: 'error' },
+  ],
+  // #1310 / #2087: rest destructure in .map() callback. All four shapes
+  // now lower via #2087 Phase B's `segments`-walking accessor:
+  //   - object-rest read via member access (`rest-destructure-object-in-map`):
+  //     `bf->omit($__bf_item, [...exclude keys...])`, `$rest->{flag}` reads
+  //     the residual hashref.
+  //   - object-rest spread onto the root element
+  //     (`rest-destructure-object-spread-in-map`): same `bf->omit(...)`
+  //     residual, forwarded via the existing `bf->spread_attrs($rest)` path.
+  //   - array-rest (`rest-destructure-array-in-map`): `bf->slice($__bf_item,
+  //     N, undef)` — the same runtime helper `.slice()` JS-method calls use.
+  //   - nested rest inside an object pattern (`rest-destructure-nested-in-map`):
+  //     the parent-prefix accessor (`$__bf_item->{cells}`) feeds the same
+  //     `bf->slice(...)` call.
+  // None of these are pinned here anymore.
+  // `style-3-signals` / `style-object-dynamic` no longer pinned — a
+  // `style={{ … }}` object literal now lowers to a CSS string with dynamic
+  // values interpolated (`background-color:<%= $color %>;padding:8px`) via
+  // `tryLowerStyleObject` (#1322).
+  // (`tagged-template-classname` graduated by #2092 — the tag resolves
+  // through the interleave-tag catalogue and desugars to an untagged
+  // template literal, so it lowers like any other className template.)
+  // #2038: a filter predicate containing a nested `.find(...)` callback.
+  // `find*` returns an element, not a boolean — there is no inline grep
+  // form, and the emitter used to degrade the call to its receiver.
+  // The nested `.some` sibling (`filter-nested-callback-predicate`) is
+  // NOT pinned: Mojo lowers it to a real inline Perl `grep` and must
+  // render to Hono parity instead.
+  // https://github.com/piconic-ai/barefootjs/issues/2038
+  'filter-nested-find-predicate': [
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2038' },
+  ],
+  // #1467 demo-corpus context providers (`radio-group`, `accordion`,
+  // `dialog`, `popover`, `select`, `dropdown-menu`, `combobox`,
+  // `command`) are no longer pinned — an object-literal provider value
+  // (`{ open: () => props.open ?? false, onOpenChange: (v) => {…} }`)
+  // lowers to a Perl hashref via `parseProviderObjectLiteral` (#1897):
+  // getter members snapshot their body's SSR value, handler /
+  // function-shaped members lower to `undef`. The command demo's
+  // `ref={(el) => {…}}` function prop on an imported component is
+  // skipped at SSR like `on*` handlers.
+  //
+  // #1467 Phase 2e: `data-table` is no longer pinned here either — it
+  // compiles clean (`selected()[index]` → `index-access`,
+  // `.toFixed(2)` → `bf->to_fixed`, `/* @client */` memo SSR-folded)
+  // and renders to Hono parity on real Mojolicious. The keyed-loop
+  // scope-ID divergence (#1896) was fixed by the body-children
+  // `inLoop` reset (loop-item children get `_bf_slot`); data-table is
+  // off `skipJsx` entirely and only kept in `skipMarkerConformance`
+  // below for the shared `/* @client */` keyed-map slot-id elision
+  // contract (same as `todo-app`), not a render or BF101 gap.
+  // #1443: `[a, b].filter(Boolean).join(' ')` (the registry Slot's
+  // shape) now lowers to `join(' ', @{[grep { $_ } @{[$a, $b]}]})`.
+  // No BF101 expected — pinned positively via the
+  // `branch-local-filter-join` template-output test below.
+  //
+  // #1448 Tier A — JS Array / String methods that the Mojo adapter
+  // hasn't lowered yet. Each row drops once the corresponding
+  // method PR lands. Hono / CSR pass these out of the box (they
+  // evaluate JS at runtime) so the pin only applies here.
+  //
+  // `array-includes` / `string-includes` no longer pinned — both
+  // shapes lower via the shared `array-method` IR + `bf->includes`
+  // runtime dispatch (#1448 Tier A first PR).
+  // `array-indexOf` / `array-lastIndexOf` no longer pinned —
+  // value-equality `bf->index_of` / `bf->last_index_of` helpers
+  // handle the shape (#1448 Tier A second PR).
+  // `array-at` no longer pinned — `bf->at` (Mojo) / `bf_at` (Go)
+  // handle the negative-index lookup (#1448 Tier A third PR).
+  // `array-concat` no longer pinned — `bf->concat` (Mojo) /
+  // `bf_concat` (Go) merge two arrays into a new array
+  // (#1448 Tier A fourth PR).
+  // `array-slice` no longer pinned — `bf->slice` (Mojo) /
+  // `bf_slice` (Go) carve out a sub-range with JS-compat
+  // negative-index / out-of-bounds clamping (#1448 Tier A
+  // fifth PR).
+  // `array-reverse` / `array-toReversed` no longer pinned —
+  // both share the `bf->reverse` / `bf_reverse` helper since
+  // SSR templates render a snapshot and the JS mutate-vs-new
+  // distinction has no template-level meaning (#1448 Tier A
+  // sixth PR).
+  // `string-toLowerCase` / `string-toUpperCase` no longer pinned —
+  // Perl's native `lc` / `uc` (Mojo) and pre-existing
+  // `bf_lower` / `bf_upper` (Go) handle the JS method names
+  // (#1448 Tier A seventh + eighth PRs).
+  // `string-trim` no longer pinned — pre-existing `bf_trim`
+  // (Go) and new `bf->trim` helper (Mojo) handle the strip
+  // (#1448 Tier A ninth PR, closing out Tier A).
+  // `.find` / `.findIndex` / `.findLast` / `.findLastIndex` are no longer
+  // pinned — the Mojo `callbackMethod` predicate arm now lowers them to the
+  // runtime `bf->find` / `find_index` / `find_last` / `find_last_index` helpers
+  // (per-element coderef predicate), matching Xslate. `.join` was never
+  // pinned (handled by `renderArrayMethod`'s `case 'join'`).
+  // #2073 follow-up: a function-reference `.map(format)` callback has no
+  // arrow body to serialize — not a CALLBACK_METHODS shape — so the
+  // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
+  // a broken template.
+  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
+}

package/src/index.ts

@@ -6,3 +6,4 @@
 
 export { MojoAdapter, mojoAdapter } from './adapter/index.ts'
 export type { MojoAdapterOptions } from './adapter/index.ts'
+export { conformancePins } from './conformance-pins.ts'

package/src/test-render.ts

@@ -213,6 +213,14 @@ export async function renderMojoComponent(options: RenderOptions): Promise<strin
       await Bun.write(resolve(tempDir, `${toSnakeCase(childName)}.html.ep`), patchTemplate(template))
     }
 
+    // Surface every `props.<x>` access as a propsParam before building
+    // the top-level stash (idempotent; the same shared pass the adapter's
+    // `generate` applies to its own IR instance — this round-tripped IR
+    // hasn't been augmented). Without it, a read reachable only through a
+    // dynamic text child / condition / loop array (#2126 follow-up) has
+    // no param entry, `buildPerlProps` seeds nothing, and the template's
+    // bare `$var` aborts under Mojo::Template's strict vars.
+    augmentInheritedPropAccesses(ir)
     // Build props hash for Perl
     const propsPerl = buildPerlProps(componentName, props, ir)