@malloy-publisher/server 0.0.209 → 0.0.211

package/src/service/materialization_service.spec.ts

@@ -11,6 +11,7 @@ import {
 } from "../errors";
 import {
    BuildInstruction,
+   MaterializationStatus,
    ResourceRepository,
 } from "../storage/DatabaseInterface";
 import { DuplicateActiveMaterializationError } from "../storage/duckdb/MaterializationRepository";
@@ -366,7 +367,9 @@ describe("MaterializationService", () => {
 
       it("drops manifest tables (and staging) when dropTables is set", async () => {
          const runSQL = sinon.stub().resolves();
-         const getMalloyConnection = sinon.stub().resolves({ runSQL });
+         const getMalloyConnection = sinon
+            .stub()
+            .resolves({ runSQL, dialectName: "duckdb" });
          (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
             getPackage: sinon.stub().resolves({ getMalloyConnection }),
             withPackageLock: async (_n: string, fn: () => Promise<unknown>) =>
@@ -395,13 +398,52 @@ describe("MaterializationService", () => {
 
          expect(getMalloyConnection.calledOnceWith("duckdb")).toBe(true);
          const dropped = runSQL.getCalls().map((c) => c.args[0] as string);
-         expect(dropped).toContain("DROP TABLE IF EXISTS orders_mz");
-         expect(dropped.some((s) => s.includes("orders_mz_"))).toBe(true);
+         expect(dropped).toContain('DROP TABLE IF EXISTS "orders_mz"');
+         expect(dropped.some((s) => s.includes('"orders_mz_'))).toBe(true);
          expect(
             ctx.repository.deleteMaterialization.calledOnceWith("mat-1"),
          ).toBe(true);
       });
 
+      it("dialect-quotes the drop DDL from the live connection (backtick + container path)", async () => {
+         const runSQL = sinon.stub().resolves();
+         const getMalloyConnection = sinon
+            .stub()
+            .resolves({ runSQL, dialectName: "standardsql" });
+         (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
+            getPackage: sinon.stub().resolves({ getMalloyConnection }),
+            withPackageLock: async (_n: string, fn: () => Promise<unknown>) =>
+               fn(),
+         });
+         ctx.repository.getMaterializationById.resolves(
+            makeMaterialization({
+               status: "MANIFEST_FILE_READY",
+               manifest: {
+                  builtAt: new Date().toISOString(),
+                  strict: false,
+                  entries: {
+                     b1: {
+                        buildId: "b1",
+                        // Container path on a hyphenated BigQuery project: each
+                        // segment must be backtick-quoted independently.
+                        physicalTableName: "my-proj.ds.engaged",
+                        connectionName: "bq",
+                     },
+                  },
+               },
+            }),
+         );
+
+         await ctx.service.deleteMaterialization("my-env", "pkg", "mat-1", {
+            dropTables: true,
+         });
+
+         const dropped = runSQL.getCalls().map((c) => c.args[0] as string);
+         expect(dropped).toContain(
+            "DROP TABLE IF EXISTS `my-proj`.`ds`.`engaged`",
+         );
+      });
+
       it("still deletes the record when a table drop fails", async () => {
          const runSQL = sinon.stub().rejects(new Error("boom"));
          const getMalloyConnection = sinon.stub().resolves({ runSQL });
@@ -706,11 +748,13 @@ describe("buildOneSource", () => {
    function callBuildOneSource(
       connection: { runSQL: sinon.SinonStub },
       physicalTableName: string,
+      dialectName?: string,
    ): Promise<{ buildId: string; physicalTableName: string }> {
       const source = fakeSource({
          name: "orders",
          buildId: "abcdef1234567890",
          sql: "SELECT * FROM t",
+         dialectName,
       });
       const instruction: BuildInstruction = {
          buildId: "abcdef1234567890",
@@ -743,10 +787,10 @@ describe("buildOneSource", () => {
 
       const sql = runSQL.getCalls().map((c) => c.args[0] as string);
       expect(sql).toEqual([
-         "DROP TABLE IF EXISTS orders_v1_abcdef123456",
-         "CREATE TABLE orders_v1_abcdef123456 AS (SELECT * FROM t)",
-         "DROP TABLE IF EXISTS orders_v1",
-         "ALTER TABLE orders_v1_abcdef123456 RENAME TO orders_v1",
+         'DROP TABLE IF EXISTS "orders_v1_abcdef123456"',
+         'CREATE TABLE "orders_v1_abcdef123456" AS (SELECT * FROM t)',
+         'DROP TABLE IF EXISTS "orders_v1"',
+         'ALTER TABLE "orders_v1_abcdef123456" RENAME TO "orders_v1"',
       ]);
       expect(entry.physicalTableName).toBe("orders_v1");
       expect(entry.buildId).toBe("abcdef1234567890");
@@ -761,8 +805,28 @@ describe("buildOneSource", () => {
          "create boom",
       );
       expect(runSQL.lastCall.args[0]).toBe(
-         "DROP TABLE IF EXISTS orders_v1_abcdef123456",
+         'DROP TABLE IF EXISTS "orders_v1_abcdef123456"',
+      );
+   });
+
+   it("quotes each segment of a container path for a backtick dialect", async () => {
+      const runSQL = sinon.stub().resolves();
+      // Container path (dataset.table) on a backtick dialect (BigQuery): each
+      // segment is quoted independently, and the rename targets the bare name.
+      const entry = await callBuildOneSource(
+         { runSQL },
+         "ds.orders_v1",
+         "standardsql",
       );
+
+      const sql = runSQL.getCalls().map((c) => c.args[0] as string);
+      expect(sql).toEqual([
+         "DROP TABLE IF EXISTS `ds`.`orders_v1_abcdef123456`",
+         "CREATE TABLE `ds`.`orders_v1_abcdef123456` AS (SELECT * FROM t)",
+         "DROP TABLE IF EXISTS `ds`.`orders_v1`",
+         "ALTER TABLE `ds`.`orders_v1_abcdef123456` RENAME TO `orders_v1`",
+      ]);
+      expect(entry.physicalTableName).toBe("ds.orders_v1");
    });
 });
 
@@ -974,3 +1038,57 @@ describe("runInBackground (terminal recording)", () => {
       expect(bg.runningAbortControllers.has("bg-3")).toBe(false);
    });
 });
+
+describe("transition (state machine)", () => {
+   let ctx: ReturnType<typeof createMocks>;
+   beforeEach(() => {
+      ctx = createMocks();
+   });
+
+   function transition(): (
+      id: string,
+      next: MaterializationStatus,
+   ) => Promise<unknown> {
+      return (
+         ctx.service as unknown as {
+            transition: (
+               id: string,
+               next: MaterializationStatus,
+            ) => Promise<unknown>;
+         }
+      ).transition.bind(ctx.service);
+   }
+
+   it("throws MaterializationNotFoundError when the record is gone", async () => {
+      ctx.repository.getMaterializationById.resolves(undefined);
+      await expect(
+         transition()("mat-1", "MANIFEST_ROWS_READY"),
+      ).rejects.toThrow(MaterializationNotFoundError);
+   });
+
+   it("rejects a transition the state machine disallows", async () => {
+      ctx.repository.getMaterializationById.resolves(
+         makeMaterialization({ status: "MANIFEST_FILE_READY" }),
+      );
+      // MANIFEST_FILE_READY is terminal; nothing follows it.
+      await expect(transition()("mat-1", "PENDING")).rejects.toThrow(
+         InvalidStateTransitionError,
+      );
+      expect(ctx.repository.updateMaterialization.called).toBe(false);
+   });
+
+   it("persists a valid transition", async () => {
+      ctx.repository.getMaterializationById.resolves(
+         makeMaterialization({ status: "PENDING" }),
+      );
+      ctx.repository.updateMaterialization.resolves(
+         makeMaterialization({ status: "MANIFEST_ROWS_READY" }),
+      );
+      await transition()("mat-1", "MANIFEST_ROWS_READY");
+      expect(
+         ctx.repository.updateMaterialization.calledOnceWith("mat-1", {
+            status: "MANIFEST_ROWS_READY",
+         }),
+      ).toBe(true);
+   });
+});

package/src/service/materialization_service.ts

@@ -30,13 +30,16 @@ import {
    ResourceRepository,
 } from "../storage/DatabaseInterface";
 import { DuplicateActiveMaterializationError } from "../storage/duckdb/MaterializationRepository";
+import { errMessage } from "../utils";
 import {
    CompiledBuildPlan,
    compilePackageBuildPlan,
    computeBuildId,
+   deriveAnnotationFields,
+   iterGraphSources,
 } from "./build_plan";
 import { EnvironmentStore } from "./environment_store";
-import { splitTablePath } from "./quoting";
+import { bareTableName, quoteIdentifier, quoteTablePath } from "./quoting";
 import { resolveEnvironmentId } from "./resolve_environment";
 
 /**
@@ -58,14 +61,7 @@ export function stagingSuffix(buildId: string): string {
  * The author owns quoting the `name=` value for the dialect.
  */
 function selfAssignTableName(persistSource: PersistSource): string {
-   try {
-      return (
-         persistSource.annotations.parseAsTag("@").tag.text("name") ||
-         persistSource.name
-      );
-   } catch {
-      return persistSource.name;
-   }
+   return deriveAnnotationFields(persistSource).name || persistSource.name;
 }
 
 /** Classify a thrown build error as cancelled (cooperative abort) or failed. */
@@ -239,9 +235,7 @@ export class MaterializationService {
          packageName,
       );
       if (active) {
-         throw new MaterializationConflictError(
-            `Package ${packageName} already has an active materialization (${active.id})`,
-         );
+         throw this.activeConflict(packageName, active.id);
       }
 
       const forceRefresh = options.forceRefresh ?? false;
@@ -265,11 +259,7 @@ export class MaterializationService {
                environmentId,
                packageName,
             );
-            throw new MaterializationConflictError(
-               winner
-                  ? `Package ${packageName} already has an active materialization (${winner.id})`
-                  : `Package ${packageName} already has an active materialization`,
-            );
+            throw this.activeConflict(packageName, winner?.id);
          }
          throw err;
       }
@@ -320,6 +310,12 @@ export class MaterializationService {
       const startedAt = Date.now();
 
       try {
+         // Persist the run's start time so the UI can compute a duration
+         // (start -> now while in-flight, start -> completed once terminal).
+         await this.repository.updateMaterialization(id, {
+            startedAt: new Date(startedAt),
+         });
+
          const environmentId = await this.resolveEnvironmentId(environmentName);
          const environment = await this.environmentStore.getEnvironment(
             environmentName,
@@ -418,35 +414,34 @@ export class MaterializationService {
       const seen = new Set<string>();
 
       for (const graph of compiled.graphs) {
-         for (const level of graph.nodes) {
-            for (const node of level) {
-               const persistSource = compiled.sources[node.sourceID];
-               if (!persistSource) continue;
-               if (include && !include.has(persistSource.name)) continue;
-
-               const buildId = computeBuildId(
-                  persistSource,
-                  compiled.connectionDigests,
-               );
-               if (seen.has(buildId)) continue;
-               seen.add(buildId);
-
-               const prior = priorEntries[buildId];
-               if (prior && prior.physicalTableName) {
-                  carried[buildId] = prior;
-                  continue;
-               }
-
-               instructions.push({
-                  buildId,
-                  materializedTableId: `local-${buildId.substring(
-                     0,
-                     STAGING_BUILD_ID_LEN,
-                  )}`,
-                  physicalTableName: selfAssignTableName(persistSource),
-                  realization: "COPY",
-               });
+         for (const persistSource of iterGraphSources(
+            graph,
+            compiled.sources,
+         )) {
+            if (include && !include.has(persistSource.name)) continue;
+
+            const buildId = computeBuildId(
+               persistSource,
+               compiled.connectionDigests,
+            );
+            if (seen.has(buildId)) continue;
+            seen.add(buildId);
+
+            const prior = priorEntries[buildId];
+            if (prior && prior.physicalTableName) {
+               carried[buildId] = prior;
+               continue;
             }
+
+            instructions.push({
+               buildId,
+               materializedTableId: `local-${buildId.substring(
+                  0,
+                  STAGING_BUILD_ID_LEN,
+               )}`,
+               physicalTableName: selfAssignTableName(persistSource),
+               realization: "COPY",
+            });
          }
       }
 
@@ -589,25 +584,21 @@ export class MaterializationService {
                `Connection '${graph.connectionName}' not found`,
             );
          }
-         for (const level of graph.nodes) {
-            for (const node of level) {
-               if (signal.aborted) throw new Error("Build cancelled");
-               const persistSource = sources[node.sourceID];
-               if (!persistSource) continue;
-
-               const buildId = computeBuildId(persistSource, connectionDigests);
-               const instruction = byBuildId.get(buildId);
-               if (!instruction) continue;
-
-               const entry = await this.buildOneSource(
-                  persistSource,
-                  instruction,
-                  connection,
-                  connectionDigests,
-                  manifest,
-               );
-               entries[buildId] = entry;
-            }
+         for (const persistSource of iterGraphSources(graph, sources)) {
+            if (signal.aborted) throw new Error("Build cancelled");
+
+            const buildId = computeBuildId(persistSource, connectionDigests);
+            const instruction = byBuildId.get(buildId);
+            if (!instruction) continue;
+
+            const entry = await this.buildOneSource(
+               persistSource,
+               instruction,
+               connection,
+               connectionDigests,
+               manifest,
+            );
+            entries[buildId] = entry;
          }
       }
 
@@ -633,32 +624,37 @@ export class MaterializationService {
          connectionDigests,
       });
 
-      const { bareName } = splitTablePath(physicalTableName);
+      const bareName = bareTableName(physicalTableName);
       const stagingTableName = `${physicalTableName}${stagingSuffix(buildId)}`;
+      // The control plane sends the logical (unquoted) physical name; dialect-
+      // quote each identifier here so a container path or quote-requiring name
+      // (e.g. a hyphenated BigQuery project id) produces valid DDL. The manifest
+      // echoes the logical name (below) so the CP stays in logical-name space.
+      const dialect = persistSource.dialectName;
+      const quotedStaging = quoteTablePath(stagingTableName, dialect);
+      const quotedPhysical = quoteTablePath(physicalTableName, dialect);
+      const quotedBareName = quoteIdentifier(bareName, dialect);
 
       const startTime = performance.now();
-      await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
+      await connection.runSQL(`DROP TABLE IF EXISTS ${quotedStaging}`);
       try {
          await connection.runSQL(
-            `CREATE TABLE ${stagingTableName} AS (${buildSQL})`,
+            `CREATE TABLE ${quotedStaging} AS (${buildSQL})`,
          );
-         await connection.runSQL(`DROP TABLE IF EXISTS ${physicalTableName}`);
+         await connection.runSQL(`DROP TABLE IF EXISTS ${quotedPhysical}`);
          await connection.runSQL(
-            `ALTER TABLE ${stagingTableName} RENAME TO ${bareName}`,
+            `ALTER TABLE ${quotedStaging} RENAME TO ${quotedBareName}`,
          );
       } catch (err) {
          try {
-            await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
+            await connection.runSQL(`DROP TABLE IF EXISTS ${quotedStaging}`);
          } catch (cleanupErr) {
             logger.warn(
                "Failed to clean up staging table after a failed build; physical leak",
                {
                   stagingTableName,
                   connectionName: persistSource.connectionName,
-                  cleanupError:
-                     cleanupErr instanceof Error
-                        ? cleanupErr.message
-                        : String(cleanupErr),
+                  cleanupError: errMessage(cleanupErr),
                },
             );
          }
@@ -795,14 +791,23 @@ export class MaterializationService {
                connection = await pkg.getMalloyConnection(connectionName);
                connectionCache.set(connectionName, connection);
             }
+            // Dialect-quote from the live connection, the same way
+            // buildOneSource quoted at build time, so a name that built
+            // successfully also drops successfully (container paths, hyphenated
+            // BigQuery project ids, etc.).
+            const dialect = connection.dialectName;
             await connection.runSQL(
-               `DROP TABLE IF EXISTS ${physicalTableName}`,
+               `DROP TABLE IF EXISTS ${quoteTablePath(
+                  physicalTableName,
+                  dialect,
+               )}`,
             );
             // A crash between staging-create and rename can leave the staging
             // table behind; clean it up too while we hold the connection.
             await connection.runSQL(
-               `DROP TABLE IF EXISTS ${physicalTableName}${stagingSuffix(
-                  entry.buildId,
+               `DROP TABLE IF EXISTS ${quoteTablePath(
+                  `${physicalTableName}${stagingSuffix(entry.buildId)}`,
+                  dialect,
                )}`,
             );
             recordDropTables("success");
@@ -817,7 +822,7 @@ export class MaterializationService {
                materializationId: m.id,
                physicalTableName,
                connectionName,
-               error: err instanceof Error ? err.message : String(err),
+               error: errMessage(err),
             });
          }
       }
@@ -848,6 +853,17 @@ export class MaterializationService {
 
    // ==================== HELPERS ====================
 
+   /** The single-active conflict error, with the winning run's id when known. */
+   private activeConflict(
+      packageName: string,
+      activeId?: string,
+   ): MaterializationConflictError {
+      const suffix = activeId ? ` (${activeId})` : "";
+      return new MaterializationConflictError(
+         `Package ${packageName} already has an active materialization${suffix}`,
+      );
+   }
+
    private recordRun(
       mode: MaterializationMode,
       outcome: "success" | "failed" | "cancelled",
@@ -865,7 +881,7 @@ export class MaterializationService {
 
       run(abortController.signal)
          .catch(async (err) => {
-            const message = err instanceof Error ? err.message : String(err);
+            const message = errMessage(err);
             const next = abortController.signal.aborted
                ? "CANCELLED"
                : "FAILED";
@@ -879,10 +895,7 @@ export class MaterializationService {
                logger.error("Failed to record materialization failure", {
                   materializationId: id,
                   originalError: message,
-                  transitionError:
-                     transitionErr instanceof Error
-                        ? transitionErr.message
-                        : String(transitionErr),
+                  transitionError: errMessage(transitionErr),
                });
             }
          })

package/src/service/materialization_test_fixtures.ts

@@ -80,11 +80,13 @@ export function fakeSource(opts: {
    buildId: string;
    sql?: string;
    connectionName?: string;
+   dialectName?: string;
 }): PersistSource {
    return {
       name: opts.name,
       sourceID: opts.name,
       connectionName: opts.connectionName ?? "duckdb",
+      dialectName: opts.dialectName ?? "duckdb",
       makeBuildId: () => opts.buildId,
       getSQL: () => opts.sql ?? "SELECT 1",
       annotations: {

package/src/service/model.ts

@@ -25,11 +25,6 @@ import * as fs from "fs/promises";
 import { createRequire } from "module";
 import * as path from "path";
 import { components } from "../api";
-import { deserializeError } from "../package_load/package_load_pool";
-import type {
-   SerializedModel,
-   SerializedNotebookCell,
-} from "../package_load/protocol";
 import {
    getDefaultQueryRowLimit,
    getMaxQueryRows,
@@ -46,8 +41,19 @@ import {
    PayloadTooLargeError,
 } from "../errors";
 import { logger } from "../logger";
+import { deserializeError } from "../package_load/package_load_pool";
+import type {
+   SerializedModel,
+   SerializedNotebookCell,
+} from "../package_load/protocol";
 import { BuildManifest } from "../storage/DatabaseInterface";
 import { URL_READER } from "../utils";
+import { modelAnnotations } from "./annotations";
+import {
+   collectAuthorizeExprs,
+   evaluateAuthorize,
+   validateAuthorizeProbes,
+} from "./authorize";
 import {
    buildFilterClause,
    FilterValidationError,
@@ -55,21 +61,15 @@ import {
    type FilterDefinition,
    type FilterParams,
 } from "./filter";
-import {
-   collectAuthorizeExprs,
-   evaluateAuthorize,
-   validateAuthorizeProbes,
-} from "./authorize";
-import { modelAnnotations } from "./annotations";
 import { malloyGivenToApi, type MalloyGiven } from "./given";
-import {
-   extractQueriesFromModelDef,
-   extractSourcesFromModelDef,
-} from "./source_extraction";
 import {
    assertWithinModelResponseLimits,
    resolveModelQueryRowLimit,
 } from "./model_limits";
+import {
+   extractQueriesFromModelDef,
+   extractSourcesFromModelDef,
+} from "./source_extraction";
 
 type ApiCompiledModel = components["schemas"]["CompiledModel"];
 type ApiNotebookCell = components["schemas"]["NotebookCell"];
@@ -980,13 +980,13 @@ export class Model {
     * annotated source view (`run: <source> -> <view>`) compile-only -- no
     * execution -- to get a stable result schema, then runs the renderer's
     * headless `validateRenderTags`. Targets with no annotations carry no render
-    * tags, so they are skipped without compiling. Any
-    * error-severity finding throws a `ModelCompilationError` (HTTP 424) so a
-    * misconfigured tag (e.g. a child-only `# big_value { sparkline=... }` placed
-    * on a view with no activating big_value) fails the package load with a clear
-    * message instead of rendering as "[object Object]" at query time. Warnings
-    * (e.g. unread tags) are left for the query-time `renderLogs` surface so a
-    * benign render lint never blocks a load.
+    * tags, so they are skipped without compiling. Any error-severity finding
+    * (e.g. a child-only `# big_value { sparkline=... }` placed on a view with no
+    * activating big_value) is logged as a warning naming the offending target;
+    * it does not fail the package load. Such a tag still renders as
+    * "[object Object]" at query time, so the warning is the operator-facing
+    * signal. Lower-severity findings are left for the query-time `renderLogs`
+    * surface.
     */
    public async validateRenderTags(): Promise<void> {
       const mm = this.modelMaterializer;
@@ -1053,11 +1053,11 @@ export class Model {
             (log) => log.severity === "error",
          );
          if (errors.length > 0) {
-            throw new ModelCompilationError({
-               message: `Invalid renderer configuration on '${target.label}': ${errors
+            logger.warn(
+               `Invalid renderer configuration on '${target.label}': ${errors
                   .map((e) => e.message)
                   .join("; ")}`,
-            });
+            );
          }
       }
    }

package/src/service/package.ts

@@ -31,9 +31,10 @@ import { formatDuration, logger } from "../logger";
 import { recordBuildPlanComputeDuration } from "../materialization_metrics";
 import { assertSafeEnvironmentPath, safeJoinUnderRoot } from "../path_safety";
 import { BuildManifest, BuildPlan } from "../storage/DatabaseInterface";
-import { ignoreDotfiles } from "../utils";
+import { errMessage, ignoreDotfiles } from "../utils";
 import { computePackageBuildPlan } from "./build_plan";
 import { Model } from "./model";
+import { assertPersistNamesQuoted } from "./persist_annotation_validation";
 
 type ApiDatabase = components["schemas"]["Database"];
 type ApiModel = components["schemas"]["Model"];
@@ -359,9 +360,19 @@ export class Package {
          );
          // Validate renderer tags on the main thread (the renderer is too heavy
          // to load inside the pure-CPU package-load worker). A misconfigured tag
-         // throws a ModelCompilationError (424), aborting the whole load like any
-         // other per-model compile error above.
+         // is logged as a warning naming the target; it does not fail the load.
          await model.validateRenderTags();
+         // Reject unquoted `#@ persist name=` annotations the same way: an
+         // unquoted name is dropped from the build plan, so the source would
+         // publish but never materialize. Scan the raw `.malloy` source (the
+         // ground truth for quoting); throws a ModelCompilationError (424).
+         if (sm.modelPath.endsWith(MODEL_FILE_SUFFIX)) {
+            const modelSource = await fs.readFile(
+               path.join(packagePath, sm.modelPath),
+               "utf-8",
+            );
+            assertPersistNamesQuoted(modelSource, sm.modelPath);
+         }
          models.set(sm.modelPath, model);
       }
 
@@ -401,7 +412,7 @@ export class Package {
             `Failed to compute build plan for package ${packageName}`,
             {
                packageName,
-               error: err instanceof Error ? err.message : String(err),
+               error: errMessage(err),
             },
          );
       }
@@ -709,9 +720,10 @@ export class Package {
                { buildManifest },
             );
             // Validate renderer tags here too (loadViaWorker does it for the
-            // create path). Reload keeps per-model placeholders rather than
-            // aborting the whole package, so a render-tag error is recorded as
-            // this model's compilationError instead of thrown.
+            // create path). Render-tag findings are logged as warnings inside
+            // validateRenderTags and never throw. The catch is defensive: an
+            // unexpected internal failure is recorded as this model's
+            // compilationError rather than aborting the whole reload.
             try {
                await model.validateRenderTags();
                nextModels.set(sm.modelPath, model);