@blockml/block-render-engine 0.0.0-stage → 0.1.0

package/blocks/org/blockml/bml/engine/blockrender/Library.bml

@@ -0,0 +1,51 @@
+<!--Block Render Engine Library
+  FQN: org.blockml.bml.engine.blockrender.Library-->
+<engine:Library xmlns="http://blockml.org/bml"
+  xmlns:blockml="org.blockml.bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:engine="org.blockml.bml.engine.blockrender">
+
+  <baseType>
+    core:BlockLibrary
+  </baseType>
+  <is>
+    The block render engine library catalog
+  </is>
+  <version>
+    0.1.0
+  </version>
+  <documentation>
+    Publishable CompilerEngine library (org.blockml.bml.engine.blockrender.Library).
+    Implements the RenderEngine contract so one RenderTarget can mix compile,
+    template, and copy strategies. MachineBlocks-agnostic.
+
+    Formerly documented as MakerEngine, package @blockml/engine-maker, folder
+    maker-engine. Those names are retired. This package is @blockml/block-render-engine.
+
+    Membership is the file tree under this Library.bml. Version 0.1.0 is inherited
+    by members that omit their own version.
+  </documentation>
+  <references>
+    <see type="engine:README" relation="ReadFirst" />
+  </references>
+  <language>
+    <blockml:language.English />
+  </language>
+  <properties>
+    <description override="true">
+      <value>Block render engine — mixed compile, template, and copy strategies</value>
+    </description>
+  </properties>
+  <aggregations>
+    <readMe override="true">
+      <composition>
+        <engine:README />
+      </composition>
+    </readMe>
+    <dependencies override="true">
+      <composition>
+        <blockml:Library />
+      </composition>
+    </dependencies>
+  </aggregations>
+</engine:Library>

package/blocks/org/blockml/bml/engine/blockrender/README.bml

@@ -0,0 +1,34 @@
+<!--Block Render Engine — README
+  FQN: org.blockml.bml.engine.blockrender.README-->
+<engine:README xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:engine="org.blockml.bml.engine.blockrender"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:ReadMe
+  </baseType>
+  <is>
+    Reading entry for the block render engine library
+  </is>
+  <documentation>
+    @blockml/block-render-engine is the first CompilerEngine implementation.
+    BlockML BOM Core names the contract RenderEngine. This package implements it.
+
+    A BlockProcessor picks a method: compile, renderTemplate, renderTemplates,
+    copyTemplate, or (later) callLLM. Several processors in the same RenderTarget
+    may pick different methods. The engine is infrastructure; processors decide
+    the strategy.
+
+    This library does not register a compiler target and does not mention
+    MachineBlocks types. Domain targets such as @machineblocks/render-target
+    construct the engine and pass it to their processors.
+
+    Start at org.blockml.bml.engine.blockrender.documentation.Introduction.
+  </documentation>
+  <references>
+    <see type="edoc:Introduction" relation="ReadFirst" />
+    <see type="edoc:RenderEngineContract" relation="SeeAlso" />
+    <see type="edoc:Strategies" relation="SeeAlso" />
+  </references>
+</engine:README>

package/blocks/org/blockml/bml/engine/blockrender/documentation/Introduction.bml

@@ -0,0 +1,47 @@
+<!--Engine Documentation — Introduction
+  FQN: org.blockml.bml.engine.blockrender.documentation.Introduction-->
+<edoc:Introduction xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:Documentation
+  </baseType>
+  <is>
+    Purpose of the block render engine
+  </is>
+  <documentation>
+    CompilerEngine is the generic term for the processing infrastructure that
+    BlockProcessors use. BOM Core defines that contract as the TypeScript
+    interface RenderEngine. This package is the V1 implementation.
+
+    It was designed around MakerUniverse use cases — physical blocks, electronics,
+    services — and was first named maker-engine / MakerEngine / @blockml/engine-maker.
+    The behaviour is unchanged. The name is block-render-engine because the job
+    is to host several render strategies in one project, not to be a MachineBlocks
+    product.
+
+    V1 covers the strategies those use cases need:
+
+    - engine.compile — deterministic code transformation
+    - engine.renderTemplate / engine.renderTemplates — template file plus substitution
+    - engine.copyTemplate — file copy, no transformation
+    - engine.callLLM — LLM generation, specified, not implemented in V1
+
+    New engines can be published as other packages that implement the same
+    interface. Examples of that shape (not this package): an XSLT engine, a Rust
+    codegen engine. There is no fixed set of engines.
+
+    The engine is browser and Node compatible. No Node-only APIs.
+
+    BlockProcessors and RenderTarget dispatch live with each target. This library
+    specifies only what those processors may call, and the context/output shapes
+    the call expects. Dispatch order (exact FQN, then baseType chain, then
+    delegates, else BML_NO_TARGET) is target behaviour; a delegate-only target
+    may omit the engine entirely.
+
+  </documentation>
+  <references>
+    <see type="edoc:Naming" relation="ReadNext" />
+  </references>
+</edoc:Introduction>

package/blocks/org/blockml/bml/engine/blockrender/documentation/MixedStrategies.bml

@@ -0,0 +1,48 @@
+<!--Engine Documentation — MixedStrategies
+  FQN: org.blockml.bml.engine.blockrender.documentation.MixedStrategies-->
+<edoc:MixedStrategies xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:Documentation
+  </baseType>
+  <is>
+    Several strategies inside one RenderTarget
+  </is>
+  <documentation>
+    One RenderTarget holds one engine instance (or none, if it only delegates)
+    and many processors. Each processor calls the method it needs. The target is
+    not labelled atomic or composite; processors plus delegates define it:
+
+    - only own processors — the target handles matching blocks itself
+    - only delegates — no engine, no processors
+    - both — some blocks handled here, others forwarded
+
+    Illustrative mix on the MachineBlocks SCAD target (the processors are owned
+    by @machineblocks/render-target; V1 of that target ships the first two):
+
+        machineblocks-v3-scad
+          ScadBlockProcessor                 compile   com.machineblocks.bml.core.Block
+          ScadSetProcessor                   compile   com.machineblocks.bml.core.Set
+          MathBuiltInProcessor               copy      org.blockml.bml.service.Math
+          CapabilityImplementationProcessor  compile   capability implementations
+
+    Dispatch, applied by the target using the engine only after a processor matches:
+
+    1. Own processors: exact FQN match.
+    2. Own processors: baseType-chain fallback. The most specific match wins.
+    3. Delegates: the same two steps, recursively.
+    4. No match: diagnostic BML_NO_TARGET.
+
+    More specific processors win over generic ones.
+
+    A delegate-only target (example: a domain library that adds Block types and
+    no new emit rules) sets engine unset, processors empty, and delegates to
+    the target that already knows how to render. It does not depend on this package.
+
+  </documentation>
+  <references>
+    <see type="edoc:RenderContext" relation="ReadNext" />
+  </references>
+</edoc:MixedStrategies>

package/blocks/org/blockml/bml/engine/blockrender/documentation/Naming.bml

@@ -0,0 +1,45 @@
+<!--Engine Documentation — Naming
+  FQN: org.blockml.bml.engine.blockrender.documentation.Naming-->
+<edoc:Naming xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:Documentation
+  </baseType>
+  <is>
+    Current names and retired aliases
+  </is>
+  <documentation>
+    Current:
+
+    - npm package: @blockml/block-render-engine
+    - BML library: org.blockml.bml.engine.blockrender.Library
+    - TypeScript class (when implemented): BlockRenderEngine
+    - import path: @blockml/block-render-engine
+
+    Retired, do not use in new text or code:
+
+    - maker-engine (folder and prose name)
+    - MakerEngine (class)
+    - @blockml/engine-maker (npm name)
+
+    Registration example a host used to write:
+
+        import { MakerEngine } from "@blockml/engine-maker";
+        registerTarget(new SomeTarget(new MakerEngine()));
+
+    The same wiring with this package:
+
+        import { BlockRenderEngine } from "@blockml/block-render-engine";
+        registerTarget(new SomeTarget(new BlockRenderEngine()));
+
+    Who calls registerTarget is the host CLI or the test/browser caller.
+    @blockml/compiler exposes registerTarget and getTarget and registers no
+    targets by itself. This package does not call registerTarget.
+
+  </documentation>
+  <references>
+    <see type="edoc:RenderEngineContract" relation="ReadNext" />
+  </references>
+</edoc:Naming>

package/blocks/org/blockml/bml/engine/blockrender/documentation/RenderContext.bml

@@ -0,0 +1,55 @@
+<!--Engine Documentation — RenderContext
+  FQN: org.blockml.bml.engine.blockrender.documentation.RenderContext-->
+<edoc:RenderContext xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:Documentation
+  </baseType>
+  <is>
+    Per-block state passed into compile and callLLM
+  </is>
+  <documentation>
+    RenderContext is internal. It is not part of the public compiler facade.
+    compile and callLLM receive it. Template and copy methods identify files by
+    path; they do not take a RenderContext in the V1 signature.
+
+    Session fields (from CompileOptions):
+
+        RenderSession
+          typeRegistry
+          sourceFilePath
+          outputBasePath
+          targetName
+          documentKind
+          activeConfig     optional
+          mbLibPath        optional — domain library root for relative imports
+
+    Per-node fields:
+
+        RenderContext
+          session
+          blockFqn
+          outputRelativePath
+          parentPartId     optional
+          partId           optional
+          instance         optional
+          withScope        readonly map of bml:with bindings
+          loopScope        optional readonly map
+          activePresetId   optional
+          child(overrides) forked context without replacing session
+
+    Composition rendering forks context via child(). Property values are resolved
+    on demand by the processor (PropertyResolver). V1 does not cache them on the
+    context.
+
+    Canonical BOM stays immutable. expandDirectives and auto-ids, when a processor
+    needs them, run on a working copy before compile. The engine does not write
+    those ids back to the BomDocument.
+
+  </documentation>
+  <references>
+    <see type="edoc:RenderOutput" relation="ReadNext" />
+  </references>
+</edoc:RenderContext>

package/blocks/org/blockml/bml/engine/blockrender/documentation/RenderEngineContract.bml

@@ -0,0 +1,58 @@
+<!--Engine Documentation — RenderEngineContract
+  FQN: org.blockml.bml.engine.blockrender.documentation.RenderEngineContract-->
+<edoc:RenderEngineContract xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:Documentation
+  </baseType>
+  <is>
+    RenderEngine methods this package implements
+  </is>
+  <documentation>
+    BOM Core defines the interface. This package implements it. Method set:
+
+        interface RenderEngine {
+          compile(block, processor, context): RenderOutput
+          renderTemplate(block, templatePath): RenderOutput
+          renderTemplates(block, templatePaths): RenderOutput
+          copyTemplate(sourcePath, targetPath): RenderOutput
+          callLLM(block, prompt, context): RenderOutput
+        }
+
+    compile — deterministic transformation. The processor supplies the algorithm
+    as processor.compile(block, context). The engine calls that method with the
+    given RenderContext and returns its RenderOutput unchanged. It does not read
+    file content. The MachineBlocks SCAD processors use this method. If the
+    processor has no compile method, compile returns files: [] and diagnostic
+    BML_ENGINE_COMPILE_CALLBACK_MISSING.
+
+    renderTemplate — load one template and substitute variables from the block.
+    renderTemplates — the same for several template paths (one processor, several
+    output files). Example shape: a processor for a device that emits a script
+    template and a config template.
+
+    copyTemplate — copy a file from sourcePath to targetPath with no rewrite.
+    Used when a service file is already the desired artifact.
+
+    callLLM — reserved. This package does not call a model.
+
+    This implementation slice runs compile. renderTemplate, renderTemplates,
+    copyTemplate, and callLLM return files: [] and diagnostic
+    BML_ENGINE_STRATEGY_UNSUPPORTED. Template substitution and file copy without
+    a Node-only API are not specified yet. callLLM stays deferred.
+
+    This package does not call registerTarget.
+
+    The engine does not choose the method. The BlockProcessor does, inside
+    process(block, engine, context). The block is a BlockDefinition or a
+    BlockInstance. The engine does not inspect it. A processor that only
+    delegates should not be given an engine call at all; its target lists
+    delegates and may leave engine unset.
+
+  </documentation>
+  <references>
+    <see type="edoc:Strategies" relation="ReadNext" />
+  </references>
+</edoc:RenderEngineContract>

package/blocks/org/blockml/bml/engine/blockrender/documentation/RenderOutput.bml

@@ -0,0 +1,38 @@
+<!--Engine Documentation — RenderOutput
+  FQN: org.blockml.bml.engine.blockrender.documentation.RenderOutput-->
+<edoc:RenderOutput xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:Documentation
+  </baseType>
+  <is>
+    What engine methods return
+  </is>
+  <documentation>
+    Every engine method returns RenderOutput. The compiler treats that value as
+    opaque. BlockML requires no file and no 1:1 input-to-output mapping. A call
+    may produce zero files, one file, many files, or side effects only.
+
+    File-based targets conventionally use:
+
+        interface FilesRenderOutput {
+          files: { path: string; content: string; sourceMap?: string }[]
+          sideEffects?: RenderSideEffect[]
+        }
+
+    files may be empty when the only result is a side effect. The side-effect
+    shape is target-defined. This package does not invent a MachineBlocks file
+    layout; the SCAD target specifies .scad paths and optional .scad.map entries.
+
+    copyTemplate's output is the copied file recorded in files (or an equivalent
+    side effect the host writes). renderTemplate's output is the substituted
+    template text. compile's output is whatever the processor's compile callback
+    produced — the engine wraps that result; it does not parse SCAD.
+
+  </documentation>
+  <references>
+    <see type="edoc:Introduction" relation="SeeAlso" />
+  </references>
+</edoc:RenderOutput>

package/blocks/org/blockml/bml/engine/blockrender/documentation/Strategies.bml

@@ -0,0 +1,60 @@
+<!--Engine Documentation — Strategies
+  FQN: org.blockml.bml.engine.blockrender.documentation.Strategies-->
+<edoc:Strategies xmlns="http://blockml.org/bml"
+  xmlns:core="org.blockml.bml.core"
+  xmlns:edoc="org.blockml.bml.engine.blockrender.documentation">
+
+  <baseType>
+    core:Documentation
+  </baseType>
+  <is>
+    How a BlockProcessor selects a strategy
+  </is>
+  <documentation>
+    A BlockProcessor is registered on a RenderTarget for a baseType. Its process
+    method calls exactly one engine strategy (or renderTemplates, which is the
+    template strategy for many files).
+
+    Compile strategy:
+
+        class ScadBlockProcessor implements BlockProcessor {
+          baseType = "com.machineblocks.bml.core.Block"
+          process(block, engine) {
+            return engine.compile(block, this, context)
+          }
+        }
+
+    Template strategy:
+
+        class NfcPlayerProcessor implements BlockProcessor {
+          baseType = "com.pimachine.nfc.NfcPlayer"
+          process(block, engine) {
+            return engine.renderTemplates(block, ["nfc_player.py.tpl", "config.json.tpl"])
+          }
+        }
+
+    Copy strategy:
+
+        class MathBuiltInProcessor implements BlockProcessor {
+          baseType = "org.blockml.bml.service.Math"
+          process(block, engine) {
+            return engine.copyTemplate("lib/math_service.scad", "lib/math_service.scad")
+          }
+        }
+
+    These class names are illustrative. The SCAD processors are specified by
+    @machineblocks/render-target, not by this package. The engine only guarantees
+    that each method is available and returns RenderOutput.
+
+    Built-in services (#math, #strings, #numbers, #lists, #bools) are BML in
+    @blockml/core (org.blockml.bml.service.*). A target that needs another
+    language form registers its own processor and chooses copy or compile.
+    Pre-rendered SCAD for those services, when present, lives in
+    @machineblocks/core under blocks/org/blockml/bml/service/. That layout is a
+    target concern.
+
+  </documentation>
+  <references>
+    <see type="edoc:MixedStrategies" relation="ReadNext" />
+  </references>
+</edoc:Strategies>

package/dist/block-render-engine.d.ts

@@ -0,0 +1,11 @@
+import type { RenderContext, RenderOutput } from "@blockml/compiler";
+import type { BlockProcessor, CompileBlock, RenderEngine } from "./types.js";
+/** First CompilerEngine. Domain-free. This slice runs compile only. */
+export declare class BlockRenderEngine implements RenderEngine {
+    compile(block: CompileBlock, processor: BlockProcessor, context: RenderContext): RenderOutput;
+    renderTemplate(block: CompileBlock, _templatePath: string): RenderOutput;
+    renderTemplates(block: CompileBlock, _templatePaths: string[]): RenderOutput;
+    copyTemplate(_sourcePath: string, _targetPath: string): RenderOutput;
+    callLLM(block: CompileBlock, _prompt: string, _context: RenderContext): RenderOutput;
+}
+//# sourceMappingURL=block-render-engine.d.ts.map

package/dist/block-render-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-render-engine.d.ts","sourceRoot":"","sources":["../src/block-render-engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE7E,uEAAuE;AACvE,qBAAa,iBAAkB,YAAW,YAAY;IACpD,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,GAAG,YAAY;IAO7F,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,GAAG,YAAY;IAIxE,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,YAAY;IAI5E,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY;IAIpE,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,YAAY;CAGrF"}

package/dist/block-render-engine.js

@@ -0,0 +1,23 @@
+import { blockSource, compileCallbackMissing, strategyUnsupported } from "./diagnostics.js";
+/** First CompilerEngine. Domain-free. This slice runs compile only. */
+export class BlockRenderEngine {
+    compile(block, processor, context) {
+        if (typeof processor.compile !== "function") {
+            return compileCallbackMissing(block);
+        }
+        return processor.compile(block, context);
+    }
+    renderTemplate(block, _templatePath) {
+        return strategyUnsupported("renderTemplate", blockSource(block));
+    }
+    renderTemplates(block, _templatePaths) {
+        return strategyUnsupported("renderTemplates", blockSource(block));
+    }
+    copyTemplate(_sourcePath, _targetPath) {
+        return strategyUnsupported("copyTemplate");
+    }
+    callLLM(block, _prompt, _context) {
+        return strategyUnsupported("callLLM", blockSource(block));
+    }
+}
+//# sourceMappingURL=block-render-engine.js.map

package/dist/block-render-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-render-engine.js","sourceRoot":"","sources":["../src/block-render-engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAG5F,uEAAuE;AACvE,MAAM,OAAO,iBAAiB;IAC5B,OAAO,CAAC,KAAmB,EAAE,SAAyB,EAAE,OAAsB;QAC5E,IAAI,OAAO,SAAS,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;YAC5C,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC;QACvC,CAAC;QACD,OAAO,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,cAAc,CAAC,KAAmB,EAAE,aAAqB;QACvD,OAAO,mBAAmB,CAAC,gBAAgB,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,eAAe,CAAC,KAAmB,EAAE,cAAwB;QAC3D,OAAO,mBAAmB,CAAC,iBAAiB,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,YAAY,CAAC,WAAmB,EAAE,WAAmB;QACnD,OAAO,mBAAmB,CAAC,cAAc,CAAC,CAAC;IAC7C,CAAC;IAED,OAAO,CAAC,KAAmB,EAAE,OAAe,EAAE,QAAuB;QACnE,OAAO,mBAAmB,CAAC,SAAS,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5D,CAAC;CACF"}

package/dist/diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { SourceLocation } from "@blockml/bom";
+import type { RenderOutput } from "@blockml/compiler";
+import type { CompileBlock } from "./types.js";
+export declare const COMPILE_CALLBACK_MISSING = "BML_ENGINE_COMPILE_CALLBACK_MISSING";
+export declare const STRATEGY_UNSUPPORTED = "BML_ENGINE_STRATEGY_UNSUPPORTED";
+export declare function compileCallbackMissing(block: CompileBlock): RenderOutput;
+export declare function strategyUnsupported(method: string, source?: SourceLocation): RenderOutput;
+export declare function blockSource(block: CompileBlock): SourceLocation;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../src/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,eAAO,MAAM,wBAAwB,wCAAwC,CAAC;AAC9E,eAAO,MAAM,oBAAoB,oCAAoC,CAAC;AAgBtE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAMxE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,cAA6B,GAAG,YAAY,CAMvG;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,cAAc,CAE/D"}

package/dist/diagnostics.js

@@ -0,0 +1,25 @@
+const EMPTY_SOURCE = { file: "", line: 1, column: 1 };
+export const COMPILE_CALLBACK_MISSING = "BML_ENGINE_COMPILE_CALLBACK_MISSING";
+export const STRATEGY_UNSUPPORTED = "BML_ENGINE_STRATEGY_UNSUPPORTED";
+function sourceOf(block) {
+    return block.source ?? EMPTY_SOURCE;
+}
+function errorOutput(code, message, source) {
+    const diagnostic = {
+        severity: "error",
+        code,
+        message,
+        source,
+    };
+    return { files: [], diagnostics: [diagnostic] };
+}
+export function compileCallbackMissing(block) {
+    return errorOutput(COMPILE_CALLBACK_MISSING, "BlockProcessor has no compile method.", sourceOf(block));
+}
+export function strategyUnsupported(method, source = EMPTY_SOURCE) {
+    return errorOutput(STRATEGY_UNSUPPORTED, `${method} is not implemented in this engine slice.`, source);
+}
+export function blockSource(block) {
+    return sourceOf(block);
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.js","sourceRoot":"","sources":["../src/diagnostics.ts"],"names":[],"mappings":"AAIA,MAAM,YAAY,GAAmB,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;AAEtE,MAAM,CAAC,MAAM,wBAAwB,GAAG,qCAAqC,CAAC;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,iCAAiC,CAAC;AAEtE,SAAS,QAAQ,CAAC,KAAmB;IACnC,OAAO,KAAK,CAAC,MAAM,IAAI,YAAY,CAAC;AACtC,CAAC;AAED,SAAS,WAAW,CAAC,IAAY,EAAE,OAAe,EAAE,MAAsB;IACxE,MAAM,UAAU,GAAe;QAC7B,QAAQ,EAAE,OAAO;QACjB,IAAI;QACJ,OAAO;QACP,MAAM;KACP,CAAC;IACF,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,KAAmB;IACxD,OAAO,WAAW,CAChB,wBAAwB,EACxB,uCAAuC,EACvC,QAAQ,CAAC,KAAK,CAAC,CAChB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAc,EAAE,SAAyB,YAAY;IACvF,OAAO,WAAW,CAChB,oBAAoB,EACpB,GAAG,MAAM,2CAA2C,EACpD,MAAM,CACP,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,KAAmB;IAC7C,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC;AACzB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { BlockRenderEngine } from "./block-render-engine.js";
+export type { BlockProcessor, CompileBlock, RenderEngine } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { BlockRenderEngine } from "./block-render-engine.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+import type { BlockDefinition, BlockInstance } from "@blockml/bom";
+import type { RenderContext, RenderOutput } from "@blockml/compiler";
+/** Document type or composition instance. The engine does not inspect it. */
+export type CompileBlock = BlockDefinition | BlockInstance;
+/** Processor registered on a RenderTarget. It chooses the engine strategy. */
+export interface BlockProcessor {
+    baseType: string;
+    process(block: CompileBlock, engine: RenderEngine, context: RenderContext): RenderOutput;
+    /** Algorithm for the compile strategy. Absent processors cannot use compile. */
+    compile?(block: CompileBlock, context: RenderContext): RenderOutput;
+}
+/** CompilerEngine contract. The processor picks the method inside process. */
+export interface RenderEngine {
+    compile(block: CompileBlock, processor: BlockProcessor, context: RenderContext): RenderOutput;
+    renderTemplate(block: CompileBlock, templatePath: string): RenderOutput;
+    renderTemplates(block: CompileBlock, templatePaths: string[]): RenderOutput;
+    copyTemplate(sourcePath: string, targetPath: string): RenderOutput;
+    callLLM(block: CompileBlock, prompt: string, context: RenderContext): RenderOutput;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAErE,6EAA6E;AAC7E,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,aAAa,CAAC;AAE3D,8EAA8E;AAC9E,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,YAAY,CAAC;IACzF,gFAAgF;IAChF,OAAO,CAAC,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,YAAY,CAAC;CACrE;AAED,8EAA8E;AAC9E,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,GAAG,YAAY,CAAC;IAC9F,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,YAAY,CAAC;IACxE,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;IAC5E,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC;IACnE,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,YAAY,CAAC;CACpF"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@blockml/block-render-engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Block render engine — one CompilerEngine that lets a RenderTarget mix compile, template, and copy strategies",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "blockml": {
+    "library": "./blocks/org/blockml/bml/engine/blockrender/Library.bml"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "blocks"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run --root ../.. packages/block-render-engine/test"
+  },
+  "dependencies": {
+    "@blockml/bom": "^0.9.13",
+    "@blockml/compiler": "^0.9.13",
+    "@blockml/core": "^1.4.2"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.