@camstack/system 1.2.347 → 1.2.349

package/dist/builtins/core-blocks/block-package.d.ts

@@ -16,8 +16,14 @@ export interface MaterializeBlockInput {
     readonly root: string;
     readonly blockId: string;
     readonly blockName: string;
-    /** The block's transpiled JavaScript. */
+    /** The block's bundled / transpiled JavaScript (written to `dist/block.js`). */
     readonly js: string;
+    /**
+     * Optional TypeScript sources (path → content). Written under `src/` so a
+     * multi-file project is inspectable on disk next to the bundle the runner
+     * loads. Absent for a legacy single-file materialize.
+     */
+    readonly files?: Readonly<Record<string, string>>;
 }
 export interface MaterializedBlock {
     /** What `$process.spawnRunner` gets as `addonDir` — the package root. */
@@ -34,6 +40,11 @@ export declare function renderBlockManifest(blockId: string, blockName: string):
  * rewrite: the author's code is the thing that changes, and a partial update
  * that left a stale `block.js` behind would run yesterday's code while the
  * editor showed today's.
+ *
+ * Layout:
+ *   `src/<path>`     — author TypeScript when `files` is provided
+ *   `dist/block.js`  — bundled / transpiled entry (what the wrapper imports)
+ *   `dist/index.js`  — generated BaseAddon wrapper
  */
 export declare function materializeBlock(input: MaterializeBlockInput): Promise<MaterializedBlock>;
 /** Remove a block's package. Idempotent — a missing directory is the desired

package/dist/builtins/core-blocks/block-settings-store.d.ts

@@ -0,0 +1,25 @@
+import { SettingsStoreClient } from '@camstack/types';
+export declare const CORE_BLOCK_SETTINGS_COLLECTION = "core-blocks:settings";
+export declare const CORE_BLOCK_SETTINGS_COLUMNS: readonly [{
+    readonly name: "id";
+    readonly type: "TEXT";
+    readonly primaryKey: true;
+    readonly notNull: true;
+}, {
+    readonly name: "values";
+    readonly type: "JSON";
+    readonly notNull: true;
+    readonly defaultValue: "{}";
+}];
+export interface BlockSettingsStoreDeps {
+    readonly store: SettingsStoreClient;
+}
+export declare class BlockSettingsStore {
+    private readonly store;
+    constructor(deps: BlockSettingsStoreDeps);
+    static declare(store: SettingsStoreClient): Promise<void>;
+    getValues(blockId: string): Promise<Record<string, unknown>>;
+    mergeValues(blockId: string, patch: Record<string, unknown>): Promise<Record<string, unknown>>;
+    delete(blockId: string): Promise<void>;
+    private mirrorToBlockAddon;
+}

package/dist/builtins/core-blocks/block-supervisor.d.ts

@@ -28,6 +28,11 @@ export interface BlockCompileOutcome {
     readonly error?: string;
     readonly js?: string;
 }
+export interface BlockCompileSource {
+    readonly code: string;
+    readonly files?: Readonly<Record<string, string>>;
+    readonly entry?: string;
+}
 /** The composer's one verb, as the supervisor needs it. */
 export interface ComposerPort {
     apply(input: ComposerApplyInput): Promise<ComposerApplyResult>;
@@ -39,7 +44,7 @@ export interface BlockSupervisorDeps {
     readonly root: string;
     readonly store: BlockStoreView;
     readonly host: BlockProcessHost;
-    readonly compile: (code: string) => Promise<BlockCompileOutcome>;
+    readonly compile: (source: BlockCompileSource) => Promise<BlockCompileOutcome>;
     readonly logger: IScopedLogger;
     /** Null when this node exposes no composer, and then every composition says so. */
     readonly composer: ComposerPort | null;

package/dist/builtins/core-blocks/compile-block.d.ts

@@ -1,4 +1,4 @@
-import { CoreBlockCompileResult } from '@camstack/types';
+import { CoreBlockCompileResult, DEFAULT_CORE_BLOCK_ENTRY } from '@camstack/types';
 /** The esbuild surface this needs — injected so the compile is testable and so
  *  the kernel does not hard-depend on a bundler at import time. */
 export interface BlockTranspiler {
@@ -9,7 +9,37 @@ export interface BlockTranspiler {
     }): Promise<{
         code: string;
     }>;
+    /**
+     * Multi-file bundle. Absent on a node that only got `transform` (tests that
+     * never exercise files); then a files compile answers "unavailable".
+     */
+    build?(options: BlockBundleOptions): Promise<BlockBundleResult>;
 }
+export interface BlockBundleOptions {
+    readonly absWorkingDir: string;
+    readonly entryPoints: readonly string[];
+    readonly outfile: string;
+    readonly bundle: true;
+    readonly format: 'esm';
+    readonly platform: 'node';
+    readonly target: string;
+    readonly write: true;
+    readonly logLevel: 'silent';
+}
+export interface BlockBundleResult {
+    readonly errors: readonly {
+        text: string;
+        location?: {
+            line: number;
+            column: number;
+        } | null;
+    }[];
+}
+export interface CompileBlockFilesInput {
+    readonly files: Readonly<Record<string, string>>;
+    readonly entry?: string;
+}
+export type CompileBlockSource = string | CompileBlockFilesInput;
 export interface CompileBlockResult extends CoreBlockCompileResult {
     /** The emitted JavaScript, when it compiled. */
     readonly js?: string;
@@ -18,4 +48,5 @@ export interface CompileBlockResult extends CoreBlockCompileResult {
  * Never throws. A compile failure is an ANSWER — the author needs to read it,
  * and a thrown error at this layer becomes a 500 with the useful part buried.
  */
-export declare function compileBlock(transpiler: BlockTranspiler, code: string): Promise<CompileBlockResult>;
+export declare function compileBlock(transpiler: BlockTranspiler, source: CompileBlockSource): Promise<CompileBlockResult>;
+export { DEFAULT_CORE_BLOCK_ENTRY };

package/dist/builtins/core-blocks/core-block-store.d.ts

@@ -120,4 +120,9 @@ export declare class CoreBlockStore {
     /** Idempotent delete — an unknown id is a no-op. */
     delete(blockId: string): Promise<void>;
     private persist;
+    /**
+     * Resolve a source-affecting patch into the normalized `{ code, files?, entry? }`
+     * that will be stored. `null` when the patch does not touch source.
+     */
+    private normalizeSourcePatch;
 }

package/dist/builtins/core-blocks/core-blocks.addon.d.ts

@@ -9,6 +9,7 @@ export declare class CoreBlocksAddon extends BaseAddon {
      */
     constructor();
     private store;
+    private prefs;
     private transpiler;
     private typeDefs;
     private supervisor;
@@ -47,13 +48,21 @@ export declare class CoreBlocksAddon extends BaseAddon {
     private convergeSoon;
     private requireStore;
     /**
-     * Compile, or explain why not.
+     * Compile, or explain why not. Returns the emitted JS so a successful gate
+     * can also extract `settingsSchema` without compiling twice.
      *
      * A missing transpiler REFUSES the write rather than waving it through: code
      * that reached disk uncompiled is code the runner will fail on, far from the
      * person who wrote it.
      */
     private gate;
+    private requirePrefs;
+    /**
+     * After a successful compile, cache the entry's `settingsSchema` export on
+     * the block when the author did not set one by hand. Never overwrites an
+     * explicit schema the editor already stored.
+     */
+    private maybeCacheSettingsSchema;
     private buildProvider;
     /**
      * The composition methods (D659), flat. Sources and existing targets are read