@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.6

package/bundled-test-harness/assets/patch-fields-test-Bp2IE0Jw.js

@@ -0,0 +1,1014 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as PatchFieldsTool } from "./patch-fields-BZwP2kAD.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, P as setupIntegrationTestRealm, Q as withHeldSave, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { h as isCard } from "./field-support-DClsIsjq.js";
+import { A as field, H as linksTo, T as containsMany, U as linksToMany, a as CardDef, l as FieldDef, s as Component, w as contains } from "./card-api-Cc8uZunB.js";
+import { t as string_default } from "./string-5IAMEUit.js";
+import { t as NumberField } from "./number-BYHu62Pt.js";
+//#region tests/integration/tools/patch-fields-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | Command | patch-fields", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, { autostart: true });
+	let toolService;
+	let AuthorDef;
+	let BookDef;
+	let store;
+	hooks.beforeEach(async function() {
+		toolService = getService("tool-service");
+		class Coordinates extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "latitude", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#latitude = (initializeDeferredDecorator(this, "latitude"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "longitude", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#longitude = (initializeDeferredDecorator(this, "longitude"), void 0);
+		}
+		class Country extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "code", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#code = (initializeDeferredDecorator(this, "code"), void 0);
+		}
+		class Address extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "street", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#street = (initializeDeferredDecorator(this, "street"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "city", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#city = (initializeDeferredDecorator(this, "city"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "zipCode", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#zipCode = (initializeDeferredDecorator(this, "zipCode"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "coordinates", [field], function() {
+					return contains(Coordinates);
+				});
+			}
+			#coordinates = (initializeDeferredDecorator(this, "coordinates"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "country", [field], function() {
+					return linksTo(Country);
+				});
+			}
+			#country = (initializeDeferredDecorator(this, "country"), void 0);
+		}
+		class Author extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "email", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#email = (initializeDeferredDecorator(this, "email"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "address", [field], function() {
+					return contains(Address);
+				});
+			}
+			#address = (initializeDeferredDecorator(this, "address"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "tags", [field], function() {
+					return containsMany(string_default);
+				});
+			}
+			#tags = (initializeDeferredDecorator(this, "tags"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "bestBook", [field], function() {
+					return linksTo(() => Book);
+				});
+			}
+			#bestBook = (initializeDeferredDecorator(this, "bestBook"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "books", [field], function() {
+					return linksToMany(() => Book);
+				});
+			}
+			#books = (initializeDeferredDecorator(this, "books"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "nV5lpWlV",
+						"block": "[[[10,\"h1\"],[12],[1,[30,1,[\"firstName\"]]],[1,\" \"],[1,[30,1,[\"lastName\"]]],[1,\" - \"],[1,[30,1,[\"email\"]]],[13],[1,\"\\n\"],[10,0],[12],[1,\"\\n  Address:\\n  \"],[8,[30,2,[\"address\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,0],[12],[1,\"\\n  Best Book:\\n  \"],[8,[30,2,[\"bestBook\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,0],[12],[1,\"All books:\"],[13],[1,\"\\n\"],[8,[30,2,[\"books\"]],null,null,null]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/tools/patch-fields-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Book extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "isbn", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#isbn = (initializeDeferredDecorator(this, "isbn"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "publishYear", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#publishYear = (initializeDeferredDecorator(this, "publishYear"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "chapters", [field], function() {
+					return containsMany(string_default);
+				});
+			}
+			#chapters = (initializeDeferredDecorator(this, "chapters"), void 0);
+		}
+		AuthorDef = Author;
+		BookDef = Book;
+		let johnTheAuthor = new Author({
+			firstName: "John",
+			lastName: "Doe",
+			email: "john@example.com",
+			address: new Address({
+				street: "123 Main St",
+				city: "Anytown",
+				zipCode: "12345"
+			}),
+			tags: ["writer", "programmer"]
+		});
+		let usa = new Country({
+			name: "United States",
+			code: "US"
+		});
+		johnTheAuthor.address.country = usa;
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"author.gts": {
+					Author,
+					Address,
+					Coordinates,
+					Book,
+					Country
+				},
+				"Book/relationship-book.json": new Book({
+					cardTitle: "Relationship Book",
+					isbn: "123-REL",
+					publishYear: 2025,
+					chapters: ["Rel 1"]
+				}),
+				"Book/book-1.json": new Book({
+					cardTitle: "Book 1",
+					isbn: "111",
+					publishYear: 2020,
+					chapters: ["A"]
+				}),
+				"Book/book-2.json": new Book({
+					cardTitle: "Book 2",
+					isbn: "222",
+					publishYear: 2021,
+					chapters: ["B"]
+				}),
+				"Book/test-book.json": new Book({
+					cardTitle: "Test Book",
+					isbn: "978-0123456789",
+					publishYear: 2023,
+					chapters: ["Introduction", "Chapter 1"]
+				}),
+				"Author/john.json": johnTheAuthor,
+				"Country/canada.json": new Country({
+					name: "Canada",
+					code: "CA"
+				}),
+				"Country/usa.json": usa
+			}
+		});
+		store = getService("store");
+	});
+	(0, import_qunit.module)("Optimistic persistence behavior", function() {
+		(0, import_qunit.test)("the patch hands the save to the background", async function(assert) {
+			assert.expect(1);
+			let patchFieldsCommand = new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef });
+			let cardId = `${testRealmURL}Author/john`;
+			let store = getService("store");
+			let patchOptions;
+			let originalPatch = store.patch;
+			store.patch = async function(id, patch, opts) {
+				patchOptions = opts;
+				return await originalPatch.call(this, id, patch, opts);
+			};
+			try {
+				await patchFieldsCommand.execute({
+					cardId,
+					fieldUpdates: { firstName: "Jane Background" }
+				});
+			} finally {
+				store.patch = originalPatch;
+			}
+			assert.true(patchOptions?.doNotWaitForPersist, "store.patch receives doNotWaitForPersist option");
+		});
+		(0, import_qunit.test)("patches do not await persistence", async function(assert) {
+			assert.expect(7);
+			let patchFieldsCommand = new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef });
+			let cardId = `${testRealmURL}Author/john`;
+			let store = getService("store");
+			let saves = 0;
+			this.onSave((url) => {
+				if (url.href === cardId) saves++;
+			});
+			let patchOptions;
+			let originalPatch = store.patch;
+			store.patch = async function(id, patch, opts) {
+				patchOptions = opts;
+				return await originalPatch.call(this, id, patch, opts);
+			};
+			try {
+				await withHeldSave(async () => {
+					let result = await patchFieldsCommand.execute({
+						cardId,
+						fieldUpdates: { firstName: "Jane Optimistic" }
+					});
+					assert.true(result.success, "command succeeds");
+					let localCard = store.peek(cardId);
+					assert.ok(localCard, "local card is present");
+					if (isCard(localCard)) assert.strictEqual(localCard.firstName, "Jane Optimistic", "local card updated immediately");
+					else assert.ok(false, "local card should be a card instance");
+					assert.strictEqual(saves, 0, "no persistence yet");
+				});
+			} finally {
+				store.patch = originalPatch;
+			}
+			assert.true(patchOptions?.doNotWaitForPersist, "store.patch receives doNotWaitForPersist option");
+			assert.true(saves > 0, `the background save completed (store save state: ${JSON.stringify(store.getSaveState(cardId))})`);
+			let persistedCard = await store.get(cardId);
+			if (isCard(persistedCard)) assert.strictEqual(persistedCard.firstName, "Jane Optimistic", "change persists after background save completes");
+			else assert.ok(false, "persisted card should exist");
+		});
+	});
+	(0, import_qunit.module)("Simple Field Update Tests", function() {
+		(0, import_qunit.module)("Relationship Update Tests", function() {
+			(0, import_qunit.test)("should update a linksTo relationship field", async function(assert) {
+				let patchFieldsCommand = new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef });
+				let bookId = `${testRealmURL}Book/relationship-book`;
+				let result = await patchFieldsCommand.execute({
+					cardId: `${testRealmURL}Author/john`,
+					fieldUpdates: { bestBook: {
+						type: "Book",
+						id: bookId
+					} }
+				});
+				assert.ok(result, "Result should be defined");
+				assert.true(result.success, "Command should succeed");
+				assert.deepEqual(result.updatedFields, ["bestBook"], "Updated fields should be correct");
+				assert.deepEqual(result.errors, {}, "No errors should be present");
+				let updatedCard = await store.get(`${testRealmURL}Author/john`);
+				if (isCard(updatedCard)) {
+					let rel = updatedCard.bestBook;
+					assert.ok(rel, "bestBook relationship should exist");
+					assert.strictEqual(rel.id, bookId, "bestBook relationship should be updated");
+				} else assert.ok(false, "Updated card should exist");
+			});
+			(0, import_qunit.test)("should update a linksToMany relationship field", async function(assert) {
+				let patchFieldsCommand = new PatchFieldsTool(toolService.toolContext);
+				let bookId1 = `${testRealmURL}Book/book-1`;
+				let bookId2 = `${testRealmURL}Book/book-2`;
+				let result = await patchFieldsCommand.execute({
+					cardId: `${testRealmURL}Author/john`,
+					fieldUpdates: { books: [{
+						type: "Book",
+						id: bookId1
+					}, {
+						type: "Book",
+						id: bookId2
+					}] }
+				});
+				assert.ok(result, "Result should be defined");
+				assert.true(result.success, "Command should succeed");
+				assert.deepEqual(result.updatedFields, ["books"], "Updated fields should be correct");
+				assert.deepEqual(result.errors, {}, "No errors should be present");
+				let updatedCard = await store.get(`${testRealmURL}Author/john`);
+				if (isCard(updatedCard)) {
+					let rel = updatedCard.books;
+					assert.ok(rel, "books relationship should exist");
+					assert.ok(Array.isArray(rel), "books relationship should be an array");
+					if (Array.isArray(rel)) {
+						assert.strictEqual(rel[0].id, bookId1, "First book id should match");
+						assert.strictEqual(rel[1].id, bookId2, "Second book id should match");
+					} else assert.ok(false, "books relationship should be an array");
+				} else assert.ok(false, "Updated card should exist");
+			});
+			(0, import_qunit.test)("should update a nested relationship field (e.g., address.country)", async function(assert) {
+				let result = await new PatchFieldsTool(toolService.toolContext).execute({
+					cardId: `${testRealmURL}Author/john`,
+					fieldUpdates: { "address.country": { id: `${testRealmURL}Country/canada` } }
+				});
+				assert.ok(result, "Result should be defined");
+				assert.true(result.success, "Command should succeed for nested relationship update");
+				assert.deepEqual(result.updatedFields, ["address.country"], "Updated fields should include the nested relationship");
+				assert.deepEqual(result.errors, {}, "No errors should be present");
+				let updatedCard = await store.get(`${testRealmURL}Author/john`);
+				if (isCard(updatedCard)) {
+					let rel = updatedCard.address?.country;
+					assert.ok(rel, "Nested country relationship should exist");
+					if (rel && typeof rel === "object" && "id" in rel) assert.strictEqual(rel.id, `${testRealmURL}Country/canada`, "Nested country relationship should be updated");
+					else assert.ok(false, "Nested country relationship data should have id");
+				} else assert.ok(false, "Updated card should exist");
+			});
+		});
+		(0, import_qunit.test)("should update single primitive field", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { firstName: "Jane" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["firstName"], "Updated fields should be correct");
+			assert.deepEqual(result.errors, {}, "No errors should be present");
+		});
+		(0, import_qunit.test)("should update multiple primitive fields", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Jane",
+					email: "jane@example.com"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["firstName", "email"], "Updated fields should be correct");
+			assert.deepEqual(result.errors, {}, "No errors should be present");
+		});
+		(0, import_qunit.test)("should return success with updated field list", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Jane",
+					lastName: "Smith",
+					email: "jane.smith@example.com"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, [
+				"firstName",
+				"lastName",
+				"email"
+			], "Updated fields should include all provided fields");
+			assert.deepEqual(result.errors, {}, "No errors should be present");
+		});
+		(0, import_qunit.test)("should preserve unchanged fields", async function(assert) {
+			let patchFieldsCommand = new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef });
+			let originalCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(originalCard)) {
+				assert.strictEqual(originalCard.firstName, "John", "Original firstName should be John");
+				assert.strictEqual(originalCard.lastName, "Doe", "Original lastName should be Doe");
+				assert.strictEqual(originalCard.email, "john@example.com", "Original email should be john@example.com");
+			} else assert.ok(false, "Original card should exist");
+			if (isCard(originalCard)) {
+				await patchFieldsCommand.execute({
+					cardId: `${testRealmURL}Author/john`,
+					fieldUpdates: { firstName: "Jane" }
+				});
+				let updatedCard = await store.get(`${testRealmURL}Author/john`);
+				if (isCard(updatedCard)) {
+					assert.strictEqual(updatedCard.firstName, "Jane", "Updated firstName should be Jane");
+					assert.strictEqual(updatedCard.lastName, "Doe", "lastName should remain unchanged");
+					assert.strictEqual(updatedCard.email, "john@example.com", "email should remain unchanged");
+				} else assert.ok(false, "Updated card should exist");
+			}
+		});
+	});
+	(0, import_qunit.module)("Nested Field Update Tests", function() {
+		(0, import_qunit.test)("should update nested object field using dot notation", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "address.city": "New York" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["address.city"], "Updated fields should be correct");
+			assert.deepEqual(result.errors, {}, "No errors should be present");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				assert.strictEqual(updatedCard.address?.city, "New York", "Nested field should be updated");
+				assert.strictEqual(updatedCard.address?.street, "123 Main St", "Other nested fields should remain unchanged");
+			} else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should update multiple nested fields", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"address.city": "San Francisco",
+					"address.zipCode": "94102",
+					firstName: "Jane"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, [
+				"address.city",
+				"address.zipCode",
+				"firstName"
+			], "Updated fields should be correct");
+			assert.deepEqual(result.errors, {}, "No errors should be present");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				assert.strictEqual(updatedCard.address?.city, "San Francisco", "Nested city field should be updated");
+				assert.strictEqual(updatedCard.address?.zipCode, "94102", "Nested zipCode field should be updated");
+				assert.strictEqual(updatedCard.firstName, "Jane", "Top-level firstName should be updated");
+				assert.strictEqual(updatedCard.address?.street, "123 Main St", "Unchanged nested field should remain the same");
+			} else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should create nested objects if they don't exist", async function(assert) {
+			let patchFieldsCommand = new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef });
+			await patchFieldsCommand.execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { address: null }
+			});
+			let result = await patchFieldsCommand.execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"address.city": "Boston",
+					"address.street": "456 Oak St"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["address.city", "address.street"], "Updated fields should be correct");
+			assert.deepEqual(result.errors, {}, "No errors should be present");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				assert.strictEqual(updatedCard.address?.city, "Boston", "Nested city field should be created and set");
+				assert.strictEqual(updatedCard.address?.street, "456 Oak St", "Nested street field should be created and set");
+			} else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should handle deep nesting (3+ levels)", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"address.coordinates.latitude": 40.7128,
+					"address.coordinates.longitude": -74.006
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["address.coordinates.latitude", "address.coordinates.longitude"], "Updated fields should be correct");
+			assert.deepEqual(result.errors, {}, "No errors should be present");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				assert.strictEqual(updatedCard.address?.coordinates?.latitude, 40.7128, "Deep nested latitude should be set");
+				assert.strictEqual(updatedCard.address?.coordinates?.longitude, -74.006, "Deep nested longitude should be set");
+				assert.strictEqual(updatedCard.address?.city, "Anytown", "Existing nested city should be preserved");
+				assert.strictEqual(updatedCard.address?.street, "123 Main St", "Existing nested street should be preserved");
+			} else assert.ok(false, "Updated card should exist");
+		});
+	});
+	(0, import_qunit.module)("Array Field Update Tests", function() {
+		(0, import_qunit.test)("should update array element by index", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "tags[1]": "developer" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["tags[1]"], "Updated fields should be correct");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) assert.deepEqual(updatedCard.tags, ["writer", "developer"], "Array element should be updated");
+			else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should update nested field within array element", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "address.street": "456 Oak Ave" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["address.street"], "Updated fields should be correct");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				let address = updatedCard.address;
+				assert.strictEqual(address?.street, "456 Oak Ave", "Nested field should be updated");
+				assert.strictEqual(address?.city, "Anytown", "Other nested fields should remain unchanged");
+			} else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should replace entire array", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { tags: [
+					"javascript",
+					"typescript",
+					"react"
+				] }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["tags"], "Updated fields should be correct");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) assert.deepEqual(updatedCard.tags, [
+				"javascript",
+				"typescript",
+				"react"
+			], "Entire array should be replaced");
+			else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should add new item to array using push syntax", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "tags[]": "new-tag" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["tags[]"], "Updated fields should be correct");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) assert.deepEqual(updatedCard.tags, [
+				"writer",
+				"programmer",
+				"new-tag"
+			], "New item should be added to array");
+			else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should add new item to array at specific index", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "tags[3]": "new-skill" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, ["tags[3]"], "Updated fields should be correct");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) assert.deepEqual(updatedCard.tags, [
+				"writer",
+				"programmer",
+				null,
+				"new-skill"
+			], "Array should be extended with null padding");
+			else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should handle mixed array and object updates", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Jane",
+					"address.city": "New City",
+					"tags[0]": "updated-writer",
+					"tags[]": "new-tag"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed");
+			assert.deepEqual(result.updatedFields, [
+				"firstName",
+				"address.city",
+				"tags[0]",
+				"tags[]"
+			], "All updates should be successful");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				assert.strictEqual(updatedCard.firstName, "Jane", "Simple field should be updated");
+				let address = updatedCard.address;
+				assert.strictEqual(address?.city, "New City", "Nested field should be updated");
+				let tags = updatedCard.tags;
+				assert.strictEqual(tags[0], "updated-writer", "Array element should be updated");
+				assert.ok(tags.includes("new-tag"), "New tag should be appended");
+			} else assert.ok(false, "Updated card should exist");
+		});
+	});
+	(0, import_qunit.module)("Validation Tests", function() {
+		(0, import_qunit.test)("should reject non-existent field paths", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { nonExistentField: "some value" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail for invalid field");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(Object.keys(result.errors).includes("nonExistentField"), "Error should be reported for invalid field");
+		});
+		(0, import_qunit.test)("should reject invalid field types", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "firstName.invalid": "some value" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail for invalid nested path");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(Object.keys(result.errors).includes("firstName.invalid"), "Error should be reported for invalid nested field");
+		});
+		(0, import_qunit.test)("should validate array bounds for existing arrays", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "tags[150]": "invalid-index" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail due to unreasonable array index");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(result.errors, "Errors should be present");
+			assert.ok(result.errors["tags[150]"], "Error should be reported for tags[150]");
+			assert.ok(result.errors["tags[150]"].includes("too far beyond current array length"), "Should report array bounds error");
+		});
+		(0, import_qunit.test)("should validate relationship field constraints", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					nonExistentRelation: "http://example.com/some-card",
+					anotherRelation: "invalid-relationship-value"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail for non-existent relationship fields");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(result.errors, "Errors should be present");
+			assert.ok(result.errors.nonExistentRelation, "Should report error for nonExistentRelation");
+			assert.ok(result.errors.anotherRelation, "Should report error for anotherRelation");
+		});
+	});
+	(0, import_qunit.module)("Partial Success Tests", function() {
+		(0, import_qunit.test)("should update valid fields when some fields fail", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Jane",
+					invalidField: "some value",
+					email: "jane@example.com"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should report success for partial updates");
+			assert.ok(result.updatedFields.includes("firstName"), "Valid firstName field should be updated");
+			assert.ok(result.updatedFields.includes("email"), "Valid email field should be updated");
+			assert.notOk(result.updatedFields.includes("invalidField"), "Invalid field should not be in updated list");
+			assert.ok(Object.keys(result.errors).includes("invalidField"), "Error should be reported for invalid field");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				assert.strictEqual(updatedCard.firstName, "Jane", "firstName should be updated");
+				assert.strictEqual(updatedCard.email, "jane@example.com", "email should be updated");
+			} else assert.ok(false, "Updated card should exist");
+		});
+		(0, import_qunit.test)("should report successful and failed fields separately", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Jane",
+					invalidField: "some value",
+					email: "jane@example.com",
+					"invalid.nested.field": "invalid"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should report success for partial updates");
+			assert.deepEqual(result.updatedFields.sort(), ["firstName", "email"].sort(), "Should report successful field updates");
+			assert.ok(result.errors, "Should have errors object");
+			assert.ok(result.errors.invalidField, "Should report error for invalidField");
+			assert.ok(result.errors["invalid.nested.field"], "Should report error for invalid nested field");
+			assert.notOk(result.errors.firstName, "Successful fields should not have errors");
+			assert.notOk(result.errors.email, "Successful fields should not have errors");
+		});
+		(0, import_qunit.test)("should return success=true for partial success", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Jane",
+					invalidField: "some value"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should return success=true when some fields succeed");
+			assert.deepEqual(result.updatedFields, ["firstName"], "Should update valid fields");
+			assert.ok(result.errors.invalidField, "Should report error for invalid field");
+		});
+		(0, import_qunit.test)("should return success=false when no fields update", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					invalidField1: "some value",
+					invalidField2: "another value",
+					"nonexistent.field": "value"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should return success=false when no fields succeed");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(result.errors, "Should have errors object");
+			assert.ok(result.errors.invalidField1, "Should report error for invalidField1");
+			assert.ok(result.errors.invalidField2, "Should report error for invalidField2");
+			assert.ok(result.errors["nonexistent.field"], "Should report error for nonexistent.field");
+		});
+	});
+	(0, import_qunit.module)("Error Handling Tests", function() {
+		(0, import_qunit.test)("should handle card not found error", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/nonexistent`,
+				fieldUpdates: { firstName: "Jane" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail for non-existent card");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(Object.keys(result.errors).includes("firstName"), "Error should be reported for the attempted update");
+			assert.ok(result.errors.firstName.includes("Card not found"), "Error message should indicate card not found");
+		});
+		(0, import_qunit.test)("should provide detailed error messages for invalid fields", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"invalid.nested.field": "some value",
+					"another.bad.field": "another value"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail for invalid fields");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(Object.keys(result.errors).includes("invalid.nested.field"), "Error should be reported for first invalid field");
+			assert.ok(Object.keys(result.errors).includes("another.bad.field"), "Error should be reported for second invalid field");
+			assert.ok(result.errors["invalid.nested.field"].includes("Invalid field path"), "Error message should indicate invalid field path");
+		});
+		(0, import_qunit.test)("should handle array index out of bounds when updating existing items", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "tags[200]": "way-out-of-bounds" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail for unreasonably high array indices");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(result.errors, "Errors should be present");
+			assert.ok(result.errors["tags[200]"], "Should report error for out of bounds index");
+			assert.ok(result.errors["tags[200]"].includes("too far beyond"), "Should report bounds checking error");
+		});
+		(0, import_qunit.test)("should allow adding beyond current array bounds (append behavior)", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { "tags[5]": "reasonable-extension" }
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed for reasonable array extensions");
+			assert.deepEqual(result.updatedFields, ["tags[5]"], "Array extension should be successful");
+			assert.deepEqual(result.errors, {}, "No errors should occur");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				let tags = updatedCard.tags;
+				assert.strictEqual(tags.length, 6, "Array should be extended");
+				assert.strictEqual(tags[5], "reasonable-extension", "Value should be set");
+				assert.strictEqual(tags[2], null, "Padding should be null");
+			}
+		});
+		(0, import_qunit.test)("should handle null reference in field paths", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"address.coordinates.latitude": 42.3601,
+					"address.coordinates.longitude": -71.0589
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should handle null references by creating objects");
+			assert.deepEqual(result.updatedFields.sort(), ["address.coordinates.latitude", "address.coordinates.longitude"].sort(), "Deep paths should be created successfully");
+			assert.deepEqual(result.errors, {}, "No errors should occur");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				let coordinates = updatedCard.address?.coordinates;
+				assert.strictEqual(coordinates?.latitude, 42.3601, "Latitude should be set");
+				assert.strictEqual(coordinates?.longitude, -71.0589, "Longitude should be set");
+			}
+		});
+		(0, import_qunit.test)("should handle malformed field paths", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"": "empty-path",
+					".invalid": "starts-with-dot",
+					"field.": "ends-with-dot",
+					"field..nested": "double-dot",
+					"field[": "unclosed-bracket",
+					"field]": "unopened-bracket"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.false(result.success, "Command should fail for malformed paths");
+			assert.deepEqual(result.updatedFields, [], "No fields should be updated");
+			assert.ok(result.errors, "Errors should be present");
+			assert.ok(result.errors[""], "Should report error for empty path");
+			assert.ok(result.errors[".invalid"], "Should report error for path starting with dot");
+			assert.ok(result.errors["field."], "Should report error for path ending with dot");
+			assert.ok(result.errors["field..nested"], "Should report error for double dots");
+			assert.ok(result.errors["field["], "Should report error for unclosed bracket");
+			assert.ok(result.errors["field]"], "Should report error for unopened bracket");
+		});
+	});
+	(0, import_qunit.module)("Field Path Parsing Tests", function() {
+		(0, import_qunit.test)("should parse simple field paths", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Jane",
+					lastName: "Smith",
+					email: "jane@example.com"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed with simple field paths");
+			assert.deepEqual(result.updatedFields.sort(), [
+				"firstName",
+				"lastName",
+				"email"
+			].sort(), "All simple fields should be parsed and updated correctly");
+			assert.deepEqual(result.errors, {}, "No parsing errors should occur");
+		});
+		(0, import_qunit.test)("should parse dot notation paths", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"address.street": "456 Oak Ave",
+					"address.city": "New City",
+					"address.coordinates.latitude": 40.7128,
+					"address.coordinates.longitude": -74.006
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed with dot notation paths");
+			assert.deepEqual(result.updatedFields.sort(), [
+				"address.street",
+				"address.city",
+				"address.coordinates.latitude",
+				"address.coordinates.longitude"
+			].sort(), "All dot notation fields should be parsed and updated correctly");
+			assert.deepEqual(result.errors, {}, "No parsing errors should occur");
+		});
+		(0, import_qunit.test)("should parse array index paths", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"tags[0]": "updated-writer",
+					"tags[1]": "updated-programmer",
+					"tags[]": "new-skill"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed with array index paths");
+			assert.deepEqual(result.updatedFields.sort(), [
+				"tags[0]",
+				"tags[1]",
+				"tags[]"
+			].sort(), "All array index fields should be parsed and updated correctly");
+			assert.deepEqual(result.errors, {}, "No parsing errors should occur");
+		});
+		(0, import_qunit.test)("should parse array append operations (e.g., \"tags[]\" or \"tags[-1]\")", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"tags[]": "appended-skill",
+					"tags[-1]": "special-append"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed with array append operations");
+			assert.deepEqual(result.updatedFields.sort(), ["tags[]", "tags[-1]"].sort(), "All append operations should be parsed and executed correctly");
+			assert.deepEqual(result.errors, {}, "No parsing errors should occur");
+			let updatedCard = await store.get(`${testRealmURL}Author/john`);
+			if (isCard(updatedCard)) {
+				let tags = updatedCard.tags;
+				assert.ok(tags.includes("appended-skill"), "Empty brackets append should work");
+				assert.ok(tags.includes("special-append"), "-1 index append should work");
+				assert.ok(tags.length >= 4, "Array should have grown");
+			}
+		});
+		(0, import_qunit.test)("should parse complex mixed paths", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "John",
+					"address.street": "123 Main St",
+					"tags[0]": "updated-tag",
+					"address.coordinates.latitude": 40.7589
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed with complex mixed paths");
+			assert.deepEqual(result.updatedFields.sort(), [
+				"firstName",
+				"address.street",
+				"tags[0]",
+				"address.coordinates.latitude"
+			].sort(), "All complex mixed paths should be parsed correctly");
+			assert.deepEqual(result.errors, {}, "No parsing errors should occur");
+		});
+		(0, import_qunit.test)("should handle edge cases in parsing", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					"tags[0]": "single-char-tag",
+					firstName: "X"
+				}
+			});
+			assert.ok(result, "Result should be defined");
+			assert.true(result.success, "Command should succeed with edge cases");
+			assert.deepEqual(result.updatedFields.sort(), ["tags[0]", "firstName"].sort(), "Edge case paths should be parsed correctly");
+			assert.deepEqual(result.errors, {}, "No parsing errors should occur for valid edge cases");
+		});
+	});
+	(0, import_qunit.module)("Schema Generation Tests", function() {
+		(0, import_qunit.test)("should generate correct JSON schema for card type", async function(assert) {
+			let schema = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).getInputJsonSchema();
+			assert.ok(schema, "Schema should be generated");
+			assert.ok(schema.attributes, "Schema should have attributes");
+			assert.ok(schema.attributes.properties, "Schema attributes should have properties");
+			assert.ok(schema.attributes.properties.cardId, "Schema should include cardId field");
+			assert.ok(schema.attributes.properties.fieldUpdates, "Schema should include fieldUpdates field");
+			let fieldUpdatesSchema = schema.attributes.properties.fieldUpdates;
+			assert.ok(fieldUpdatesSchema.properties, "FieldUpdates should have properties based on card type");
+			assert.ok(fieldUpdatesSchema.properties.firstName, "Should include firstName field from Author card");
+			assert.ok(fieldUpdatesSchema.properties.lastName, "Should include lastName field from Author card");
+			assert.ok(fieldUpdatesSchema.properties.email, "Should include email field from Author card");
+		});
+		(0, import_qunit.test)("should include field descriptions in schema", async function(assert) {
+			let schema = await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).getInputJsonSchema();
+			assert.ok(schema.attributes.properties.cardId.description, "cardId field should have description");
+			assert.ok(schema.attributes.properties.fieldUpdates.description, "fieldUpdates field should have description");
+			assert.strictEqual(schema.attributes.properties.cardId.description, "The ID of the card to update", "cardId should have correct description");
+			assert.strictEqual(schema.attributes.properties.fieldUpdates.description, "Object containing field paths and their new values", "fieldUpdates should have correct description");
+		});
+		(0, import_qunit.test)("should support nested field schemas", async function(assert) {
+			let fieldUpdatesSchema = (await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).getInputJsonSchema()).attributes.properties.fieldUpdates;
+			assert.ok(fieldUpdatesSchema.properties.address, "Should include address field for nested updates");
+			assert.true(fieldUpdatesSchema.additionalProperties, "Should allow additional properties for nested field paths");
+		});
+		(0, import_qunit.test)("should handle array field schemas", async function(assert) {
+			let fieldUpdatesSchema = (await new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef }).getInputJsonSchema()).attributes.properties.fieldUpdates;
+			assert.ok(fieldUpdatesSchema.properties.tags, "Should include tags array field");
+			assert.true(fieldUpdatesSchema.additionalProperties, "Should allow additional properties for array field paths");
+		});
+	});
+	(0, import_qunit.module)("Dynamic Field Validation Tests", function() {
+		(0, import_qunit.test)("should work with different card types (not just hardcoded Author fields)", async function(assert) {
+			let result = await new PatchFieldsTool(toolService.toolContext, { cardType: BookDef }).execute({
+				cardId: `${testRealmURL}Book/test-book`,
+				fieldUpdates: { cardTitle: "Updated Book Title" }
+			});
+			assert.true(result.success, "Should successfully validate and update Book fields with dynamic validation");
+			assert.strictEqual(result.updatedFields.length, 1, "Should update the title field");
+			assert.strictEqual(result.updatedFields[0], "cardTitle", "Should update the cardTitle field");
+			assert.deepEqual(result.errors, {}, "Should have no validation errors");
+		});
+		(0, import_qunit.test)("should now accept fields that would have been rejected by hardcoded validation", async function(assert) {
+			let patchFieldsCommand = new PatchFieldsTool(toolService.toolContext, { cardType: AuthorDef });
+			let result = await patchFieldsCommand.execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: {
+					firstName: "Updated John",
+					lastName: "Updated Doe"
+				}
+			});
+			assert.true(result.success, "Should successfully validate existing Author fields");
+			assert.deepEqual(result.updatedFields.sort(), ["firstName", "lastName"].sort(), "Should update valid Author fields");
+			assert.deepEqual(result.errors, {}, "Should have no validation errors for valid fields");
+			let invalidResult = await patchFieldsCommand.execute({
+				cardId: `${testRealmURL}Author/john`,
+				fieldUpdates: { invalidField: "Some value" }
+			});
+			assert.false(invalidResult.success, "Should reject truly invalid fields");
+			assert.ok(invalidResult.errors.invalidField?.includes("Invalid field path"), `Should get validation error for truly invalid field, got: ${invalidResult.errors.invalidField}`);
+		});
+	});
+});
+//#endregion