@@ -0,0 +1,10 @@
+---
+'@objectstack/service-datasource': patch
+---
+
+fix(service-datasource): an object drafted or imported from an external datasource table gives each field a readable label
+
+Clause-②: no
+Metadata-protocol: none
+
+Every field of a generated object draft (`generateObjectDraft`, `importObject`, `os datasource introspect`) now carries a `label`, derived from the field's name by the same snake_case to Title Case step that already labels the object: a table with columns `part_no` and `part_name` yields fields labelled `Part No` and `Part Name`, so the record form of a synced object no longer shows raw column names. The label follows the name the field is saved under (after `rename` and the numbering of a taken name), a lookup keeps the label of the column it replaces, and the rendered `*.object.ts` source carries the same label. The object's own label is unchanged. Objects imported before this release keep their stored fields; re-import or edit the labels to change them.
@@ -110,7 +110,7 @@ describe('generateObjectDraft', () => {
      * Where the key went instead is pinned in
      * `external-object-draft-primary-key.test.ts`.
      */
-    expect(fields.order_id).toEqual({ type: 'text' });
+    expect(fields.order_id).toEqual({ type: 'text', label: 'Order Id' });
     expect(fields.amount.type).toBe('number');
     expect(fields.ordered_at.type).toBe('datetime');
     expect(fields.metadata.type).toBe('json');
@@ -124,7 +124,7 @@ describe('generateObjectDraft', () => {
     expect(draft.source).toContain('REVIEW:');
     // Same flip, source side: the rendered field line no longer carries the
     // key, and the introspected key survives as the comment ruling D requires.
-    expect(draft.source).toContain("order_id: { type: 'text' },");
+    expect(draft.source).toContain("order_id: { type: 'text', label: 'Order Id' },");
     expect(draft.source).not.toContain('primaryKey: true');
     expect(draft.source).toContain('// Remote primary key: order_id');
   });
@@ -224,6 +224,80 @@ describe('importObject', () => {
   });
 });
 
+/**
+ * Every generated field carries a readable label, derived by the SAME function
+ * that labels the object (snake_case → Title Case). Without one the record
+ * form of a synced object shows the raw column name (`part_no`) as the input's
+ * label, while the object itself reads as a sentence.
+ */
+describe('generated field labels', () => {
+  function sparePartsSchema(): IntrospectedSchema {
+    return {
+      dialect: 'sqlite',
+      introspectedAt: '2026-11-05T00:00:00.000Z',
+      tables: {
+        spare_parts: {
+          name: 'spare_parts',
+          indexes: [],
+          columns: [
+            { name: 'id', type: 'integer', nullable: false, primaryKey: true },
+            { name: 'part_no', type: 'text', nullable: false, primaryKey: false },
+            { name: 'part_name', type: 'text', nullable: true, primaryKey: false },
+            { name: 'PartNo', type: 'text', nullable: true, primaryKey: false },
+          ],
+        },
+      },
+    };
+  }
+  function makeSpareParts() {
+    const persisted: Array<{ name: string; def: Record<string, unknown> }> = [];
+    const svc = new ExternalDatasourceService({
+      introspect: async () => sparePartsSchema(),
+      getDatasource: async () => ({ name: 'parts_db', schemaMode: 'external' }),
+      getObject: async () => undefined,
+      listObjects: async () => [],
+      persistObject: async (name, def) => { persisted.push({ name, def }); },
+    });
+    return { svc, persisted };
+  }
+
+  it('labels each field of the draft from its field name, and the object label is unchanged', async () => {
+    const { svc } = makeSpareParts();
+    const draft = await svc.generateObjectDraft('parts_db', 'spare_parts');
+    const fields = draft.definition.fields as Record<string, { type: string; label?: string }>;
+    expect(fields.id).toEqual({ type: 'number', label: 'Id' });
+    expect(fields.part_no).toEqual({ type: 'text', label: 'Part No' });
+    expect(fields.part_name).toEqual({ type: 'text', label: 'Part Name' });
+    // A column that is not snake_case is labelled from the field name it is
+    // saved under (`PartNo` → `part_no`, taken → `part_no_2`), never from the
+    // raw remote spelling.
+    expect(fields.part_no_2).toEqual({ type: 'text', label: 'Part No 2' });
+    // Control: the object label is derived exactly as before.
+    expect(draft.definition.label).toBe('Spare Parts');
+    // The rendered source carries the same label the definition does.
+    expect(draft.source).toContain("part_no: { type: 'text', label: 'Part No' },");
+  });
+
+  it('a renamed column is labelled from the name it is renamed to', async () => {
+    const { svc } = makeSpareParts();
+    const draft = await svc.generateObjectDraft('parts_db', 'spare_parts', {
+      includeColumns: ['part_no'],
+      rename: { part_no: 'catalogue_number' },
+    });
+    const fields = draft.definition.fields as Record<string, { label?: string }>;
+    expect(fields.catalogue_number?.label).toBe('Catalogue Number');
+  });
+
+  it('the persisted object of an import carries the same field labels', async () => {
+    const { svc, persisted } = makeSpareParts();
+    await svc.importObject('parts_db', 'spare_parts');
+    const def = persisted[0]!.def as { label: string; fields: Record<string, { label?: string }> };
+    expect(def.fields.part_no?.label).toBe('Part No');
+    expect(def.fields.part_name?.label).toBe('Part Name');
+    expect(def.label).toBe('Spare Parts');
+  });
+});
+
 /**
  * ADR-0028 namespace prefix on the `opts.name` OVERRIDE path (#11061).
  *
 
@@ -90,12 +90,12 @@ describe('an OData entity set drafts with EDM types mapped and snake_case fields
 
     expect(draft.name).toBe('products');
     expect(draft.definition.fields).toEqual({
-      product_id: { type: 'number' },
-      product_name: { type: 'text' },
-      supplier_id: { type: 'number' },
-      category_id: { type: 'number' },
-      unit_price: { type: 'number' },
-      discontinued: { type: 'boolean' },
+      product_id: { type: 'number', label: 'Product Id' },
+      product_name: { type: 'text', label: 'Product Name' },
+      supplier_id: { type: 'number', label: 'Supplier Id' },
+      category_id: { type: 'number', label: 'Category Id' },
+      unit_price: { type: 'number', label: 'Unit Price' },
+      discontinued: { type: 'boolean', label: 'Discontinued' },
     });
     expect(draft.definition.external).toEqual({
       remoteName: 'Products',
@@ -169,7 +169,7 @@ describe('navigations become lookups only where a column holds the key of an imp
       supplier_id: { type: 'number' },
     });
     expect(draft.review.map((r) => r.column)).toEqual(['Supplier']);
-    expect(draft.source).toContain("    category_id: { type: 'lookup', reference: 'categories' },");
+    expect(draft.source).toContain("    category_id: { type: 'lookup', label: 'Category Id', reference: 'categories' },");
     expect(draft.source).toContain("columnMap: { 'ProductID': 'product_id',");
   });
 
@@ -306,12 +306,12 @@ describe('an OData v2 datasource imports the same way: Associations become looku
     const { service } = serviceOverV2();
     const products = await service.generateObjectDraft('erp', 'Products');
     expect(products.definition.fields).toEqual({
-      product_id: { type: 'number' },
-      product_name: { type: 'text' },
-      supplier_id: { type: 'number' },
-      category_id: { type: 'number' },
-      unit_price: { type: 'number' },
-      discontinued: { type: 'boolean' },
+      product_id: { type: 'number', label: 'Product Id' },
+      product_name: { type: 'text', label: 'Product Name' },
+      supplier_id: { type: 'number', label: 'Supplier Id' },
+      category_id: { type: 'number', label: 'Category Id' },
+      unit_price: { type: 'number', label: 'Unit Price' },
+      discontinued: { type: 'boolean', label: 'Discontinued' },
     });
     const employees = await service.generateObjectDraft('erp', 'Employees');
     expect(employees.definition.fields).toMatchObject({ birth_date: { type: 'datetime' } });
 
@@ -190,8 +190,8 @@ describe('still-generates — the fix must not be satisfied by emitting a valid
     expect(fields.name.type).toBe('text');
     expect(fields.signed_up_at.type).toBe('datetime');
 
-    expect(draft.source).toContain("id: { type: 'text' }");
-    expect(draft.source).toContain("signed_up_at: { type: 'datetime' }");
+    expect(draft.source).toContain("id: { type: 'text', label: 'Id' }");
+    expect(draft.source).toContain("signed_up_at: { type: 'datetime', label: 'Signed Up At' }");
   });
 
   it('keeps the external binding pointed at the REMOTE table, not the renamed object', async () => {
 
@@ -122,7 +122,7 @@ describe('direction 1 — the unauthorable key is ABSENT from the definition', (
     });
 
     for (const [name, record] of fieldRecords(draft)) {
-      expect(Object.keys(record), `field '${name}'`).toEqual(['type']);
+      expect(Object.keys(record), `field '${name}'`).toEqual(['type', 'label']);
     }
     // Spelled twice on purpose: the loop above forbids ANY extra key, this
     // line names the one the defect was about, so a regression reports it.
@@ -133,15 +133,15 @@ describe('direction 1 — the unauthorable key is ABSENT from the definition', (
     const draft = await svc().generateObjectDraft('warehouse', 'orders');
 
     const fields = draft.definition.fields as Record<string, object>;
-    expect(Object.keys(fields.order_id)).toEqual(['type']);
+    expect(Object.keys(fields.order_id)).toEqual(['type', 'label']);
     expect(JSON.stringify(draft.definition)).not.toContain('primaryKey');
   });
 
   it('renders no `primaryKey:` onto the field LINE either', async () => {
     const draft = await svc().generateObjectDraft('warehouse', 'orders', {
       primaryKey: ['order_id'],
     });
-    expect(draft.source).toContain("order_id: { type: 'text' },");
+    expect(draft.source).toContain("order_id: { type: 'text', label: 'Order Id' },");
     expect(draft.source).not.toContain('primaryKey: true');
   });
 });
 
@@ -105,9 +105,9 @@ describe('generateObjectDraft, driven off a real SqlDriver.introspectSchema()',
     // …and it is the introspected key, not "the first column": a table whose
     // key is not first is covered below.
     expect(draft.definition.fields).toEqual({
-      id: { type: 'text' },
-      name: { type: 'text' },
-      age: { type: 'number' },
+      id: { type: 'text', label: 'Id' },
+      name: { type: 'text', label: 'Name' },
+      age: { type: 'number', label: 'Age' },
     });
 
     // The key survives as a comment and NOWHERE else. `fields.<f>.primaryKey`
 
@@ -411,8 +411,12 @@ function navigationCandidates(table: IntrospectedTable): NavigationCandidate[] {
   return out;
 }
 
-/** A field of a generated draft: a scalar, or a lookup over a foreign-key column. */
-type DraftField = { type: FieldType; reference?: string };
+/**
+ * A field of a generated draft: a scalar, or a lookup over a foreign-key column.
+ * `label` is derived from the field name by {@link toLabel}, the one derivation
+ * the object's own label uses, so a synced object's forms read as sentences.
+ */
+type DraftField = { type: FieldType; label: string; reference?: string };
 
 /**
  * The org-wide default every generated federated object declares.
@@ -915,7 +919,9 @@ export class ExternalDatasourceService implements IExternalDatasourceService {
       }
 
       const isPk = pkOverride ? pkOverride.has(col.name) : col.primaryKey;
-      fields[fieldName] = { type: fieldType };
+      // Labelled from the FIELD name (after rename and numbering), never the
+      // raw remote spelling: the same derivation as the object's label below.
+      fields[fieldName] = { type: fieldType, label: toLabel(fieldName) };
       if (isPk) primaryKeyFields.push(fieldName);
     }
 
@@ -1067,7 +1073,7 @@ export class ExternalDatasourceService implements IExternalDatasourceService {
         leftOut(`'${target}' is not imported on datasource '${datasource}'; import it before this table to get the lookup`);
         continue;
       }
-      fields[field] = { type: 'lookup', reference };
+      fields[field] = { type: 'lookup', label: fields[field]!.label, reference };
     }
   }
 
@@ -1527,7 +1533,7 @@ function renderObjectSource(
     const note = reviewByField.get(fieldName);
     const comment = note ? ` // REVIEW: ${note}` : '';
     const reference = f.reference ? `, reference: ${quoteTs(f.reference)}` : '';
-    return `    ${fieldName}: { type: '${f.type}'${reference} },${comment}`;
+    return `    ${fieldName}: { type: '${f.type}', label: ${quoteTs(f.label)}${reference} },${comment}`;
   });
   const unplacedLines = unplaced.map((r) => `    // REVIEW: ${r.column} (${r.remoteType}): ${r.note}`);