@porulle/core 0.6.0 → 0.8.0

package/src/modules/catalog/entity-service.ts

@@ -181,13 +181,22 @@ export class EntityService {
     }
     if (options?.includeCategories) hydrated.categories = await this.repo.findEntityCategories(entity.id, ctx);
     if (options?.includeBrands) hydrated.brands = await this.repo.findEntityBrands(entity.id, ctx);
-    if (options?.includeMedia) hydrated.media = [];
+    if (options?.includeMedia) {
+      const mediaService = this.deps.services.media as {
+        listEntityMedia?: (
+          entityId: string,
+          opts?: { orgId?: string },
+        ) => Promise<{ ok: boolean; value?: CatalogEntityHydrated["media"] }>;
+      } | undefined;
+      const mediaResult = await mediaService?.listEntityMedia?.(entity.id, { orgId: entity.organizationId });
+      hydrated.media = mediaResult?.ok && mediaResult.value ? mediaResult.value : [];
+    }
     if (options?.includePricing) {
       try {
-        const pricingService = this.deps.services.pricing as { listPrices: (filter: { entityId: string }) => Promise<{ ok: boolean; value?: { prices: Array<{ currency: string; amount: number; compareAtAmount?: number | null }> } }> };
+        const pricingService = this.deps.services.pricing as { listPrices: (filter: { entityId: string }) => Promise<{ ok: boolean; value?: { prices: Array<{ id: string; currency: string; amount: number; compareAtAmount?: number | null; createdAt: Date }> } }> };
         const priceResult = await pricingService.listPrices({ entityId: entity.id });
         if (priceResult.ok && priceResult.value) {
-          hydrated.pricing = priceResult.value.prices.map((p) => ({ currency: p.currency, amount: p.amount, compareAtAmount: p.compareAtAmount ?? null }));
+          hydrated.pricing = priceResult.value.prices.map((p) => ({ id: p.id, currency: p.currency, amount: p.amount, compareAtAmount: p.compareAtAmount ?? null, createdAt: p.createdAt }));
         }
       } catch {}
     }
@@ -203,7 +212,7 @@ export class EntityService {
     const afterHooks = this.deps.hooks.resolve("catalog.afterCreate") as CatalogCreateAfterHook[];
     const context: HookContext = createHookContext({ actor, tx: ctx?.tx ?? null, logger: createLogger("catalog.create"), services: this.deps.services, context: { moduleName: "catalog" }, ...hookDatabaseArg(this.deps.database) });
     const processedInput = await runBeforeHooks(beforeHooks, input, "create", context);
-    const entity = await this.repo.createEntity({ organizationId: orgId, type: processedInput.type, slug: processedInput.slug, status: "draft", isVisible: false, metadata: processedInput.metadata ?? {} }, ctx);
+    const entity = await this.repo.createEntity({ organizationId: orgId, type: processedInput.type, slug: processedInput.slug, status: "draft", isVisible: false, ...(processedInput.taxClass !== undefined ? { taxClass: processedInput.taxClass } : {}), metadata: processedInput.metadata ?? {} }, ctx);
     if (processedInput.attributes) {
       await this.repo.createAttribute({ entityId: entity.id, locale: processedInput.attributes.locale ?? "en", title: processedInput.attributes.title, subtitle: processedInput.attributes.subtitle, description: processedInput.attributes.description, richDescription: processedInput.attributes.richDescription, seoTitle: processedInput.attributes.seoTitle, seoDescription: processedInput.attributes.seoDescription }, ctx);
     }
@@ -223,7 +232,7 @@ export class EntityService {
     const afterHooks = this.deps.hooks.resolve("catalog.afterUpdate") as CatalogUpdateAfterHook[];
     const context: HookContext = createHookContext({ actor, tx: ctx?.tx ?? null, logger: createLogger("catalog.update"), services: this.deps.services, context: { moduleName: "catalog" }, ...hookDatabaseArg(this.deps.database) });
     const processed = await runBeforeHooks(beforeHooks, input, "update", context);
-    const updated = await this.repo.updateEntity(id, { ...(processed.slug !== undefined ? { slug: processed.slug } : {}), ...(processed.status !== undefined ? { status: processed.status as SellableEntity["status"] } : {}), ...(processed.metadata !== undefined ? { metadata: processed.metadata } : {}), ...(processed.isVisible !== undefined ? { isVisible: processed.isVisible } : {}) }, ctx);
+    const updated = await this.repo.updateEntity(id, { ...(processed.slug !== undefined ? { slug: processed.slug } : {}), ...(processed.status !== undefined ? { status: processed.status as SellableEntity["status"] } : {}), ...(processed.taxClass !== undefined ? { taxClass: processed.taxClass } : {}), ...(processed.metadata !== undefined ? { metadata: processed.metadata } : {}), ...(processed.isVisible !== undefined ? { isVisible: processed.isVisible } : {}) }, ctx);
     if (!updated) return Err(new CommerceNotFoundError("Entity not found."));
     const hookReport = await runAfterHooks(afterHooks, existing, updated, "update", context);
     const hydrated = await this.hydrateEntity(updated, undefined, ctx);
@@ -428,13 +437,28 @@ export class EntityService {
       if (!ov) return Err(new CommerceValidationError(`Option value "${optVal}" does not exist for option type "${optName}".`));
       optionValueIds.push(ov.id);
     }
-    const variant = await this.repo.createVariant({ entityId: input.entityId, status: "active", sortOrder: 0, metadata: {}, ...(input.sku !== undefined ? { sku: input.sku } : {}) }, ctx);
+    const variant = await this.repo.createVariant({ entityId: input.entityId, status: "active", sortOrder: 0, metadata: {}, ...(input.sku !== undefined ? { sku: input.sku } : {}), ...(input.taxClass !== undefined ? { taxClass: input.taxClass } : {}) }, ctx);
     await this.repo.createVariantOptionValues(optionValueIds.map((optionValueId) => ({ variantId: variant.id, optionValueId })), ctx);
     return Ok(variant);
   }
 
   async generateVariants(entityId: string, strategy: VariantGenerationStrategy, actor: Actor | null, ctx?: TxContext): Promise<Result<Variant[]>> {
     assertPermission(actor, "catalog:update");
+    // Guard the strategy: a missing/malformed body (e.g. a bodyless SDK call that
+    // skips JSON validation) must be a 422, not a 500 from dereferencing an
+    // undefined strategy.
+    const mode = (strategy as { mode?: unknown } | null | undefined)?.mode;
+    if (mode !== "all" && mode !== "manual" && mode !== "matrix") {
+      return Err(new CommerceValidationError(
+        'A variant generation strategy is required: { "mode": "all" } | { "mode": "manual", "combinations": [...] } | { "mode": "matrix", "matrix": { "include"?, "exclude"? } }.',
+      ));
+    }
+    if (strategy.mode === "manual" && !Array.isArray(strategy.combinations)) {
+      return Err(new CommerceValidationError('strategy.combinations (string[][]) is required for mode "manual".'));
+    }
+    if (strategy.mode === "matrix" && (!strategy.matrix || typeof strategy.matrix !== "object")) {
+      return Err(new CommerceValidationError('strategy.matrix is required for mode "matrix".'));
+    }
     const entity = await this.repo.findEntityById(entityId, ctx);
     if (!entity) return Err(new CommerceNotFoundError("Entity not found."));
     const entityOptionTypes = await this.repo.findOptionTypesByEntityId(entityId, ctx);
@@ -466,4 +490,169 @@ export class EntityService {
     }
     return Ok(created);
   }
+
+  // ── One-call variant creation (issue #50) ────────────────────────────────
+  // Upserts option axes inline, creates variants, and seeds a zero-stock
+  // inventory level per variant so it is sellable immediately. Retry-safe:
+  // axes upsert by name/value and existing combinations are skipped.
+
+  private async upsertAxes(
+    entityId: string,
+    axes: Array<{ name: string; values: string[] }>,
+    ctx?: TxContext,
+  ): Promise<Map<string, Map<string, string>>> {
+    const existingTypes = await this.repo.findOptionTypesByEntityId(entityId, ctx);
+    const result = new Map<string, Map<string, string>>();
+    for (const axis of axes) {
+      let optionType = existingTypes.find((t) => t.name === axis.name);
+      if (!optionType) {
+        optionType = await this.repo.createOptionType(
+          { entityId, name: axis.name, displayName: axis.name, sortOrder: existingTypes.length },
+          ctx,
+        );
+        existingTypes.push(optionType);
+      }
+      const existingValues = await this.repo.findOptionValuesByTypeId(optionType.id, ctx);
+      const valueIds = new Map<string, string>();
+      for (const value of axis.values) {
+        let optionValue = existingValues.find((v) => v.value === value);
+        if (!optionValue) {
+          optionValue = await this.repo.createOptionValue(
+            { optionTypeId: optionType.id, value, displayValue: value, sortOrder: existingValues.length, metadata: {} },
+            ctx,
+          );
+          existingValues.push(optionValue);
+        }
+        valueIds.set(value, optionValue.id);
+      }
+      result.set(axis.name, valueIds);
+    }
+    return result;
+  }
+
+  private async existingComboKeys(entityId: string, ctx?: TxContext): Promise<Map<string, string>> {
+    const existing = new Map<string, string>();
+    for (const variant of await this.repo.findVariantsByEntityId(entityId, ctx)) {
+      const rows = await this.repo.findVariantOptionValues(variant.id, ctx);
+      const key = rows.map((r) => r.optionValueId).sort().join("|");
+      existing.set(key, variant.id);
+    }
+    return existing;
+  }
+
+  private async seedInventoryLevel(
+    entityId: string,
+    variantId: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<unknown>> {
+    const inventory = this.deps.services.inventory as {
+      adjustDetailed: (
+        input: { entityId: string; variantId?: string; adjustment: number; reason: string },
+        actor?: Actor | null,
+        ctx?: TxContext,
+      ) => Promise<Result<unknown>>;
+    };
+    return inventory.adjustDetailed(
+      { entityId, variantId, adjustment: 0, reason: "Variant created — seed zero-stock level" },
+      actor,
+      ctx,
+    );
+  }
+
+  async quickCreateVariant(
+    entityId: string,
+    input: { options: Record<string, string>; sku?: string | undefined; barcode?: string | undefined },
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ variant: Variant; created: boolean }>> {
+    try { assertPermission(actor, "catalog:update"); } catch (error) { return Err(toCommerceError(error)); }
+    const entity = await this.repo.findEntityById(entityId, ctx);
+    if (!entity) return Err(new CommerceNotFoundError("Entity not found."));
+    try { this.assertSameOrg(entity, actor); } catch (error) { return Err(toCommerceError(error)); }
+
+    const axes = Object.entries(input.options).map(([name, value]) => ({ name, values: [value] }));
+    const axisValueIds = await this.upsertAxes(entityId, axes, ctx);
+    const optionValueIds = Object.entries(input.options)
+      .map(([name, value]) => axisValueIds.get(name)!.get(value)!);
+
+    const key = [...optionValueIds].sort().join("|");
+    const existing = await this.existingComboKeys(entityId, ctx);
+    const existingVariantId = existing.get(key);
+    if (existingVariantId !== undefined) {
+      const variant = await this.repo.findVariantById(existingVariantId, ctx);
+      return Ok({ variant: variant!, created: false });
+    }
+
+    const variant = await this.repo.createVariant(
+      {
+        entityId,
+        status: "active",
+        sortOrder: 0,
+        metadata: { generatedBy: "quick" },
+        ...(input.sku !== undefined ? { sku: input.sku } : {}),
+        ...(input.barcode !== undefined ? { barcode: input.barcode } : {}),
+      },
+      ctx,
+    );
+    await this.repo.createVariantOptionValues(
+      optionValueIds.map((optionValueId) => ({ variantId: variant.id, optionValueId })),
+      ctx,
+    );
+    const seeded = await this.seedInventoryLevel(entityId, variant.id, actor, ctx);
+    if (!seeded.ok) return seeded;
+    return Ok({ variant, created: true });
+  }
+
+  async bulkCreateVariants(
+    entityId: string,
+    input: { axes: Array<{ name: string; values: string[] }>; skuPrefix?: string | undefined },
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ created: Variant[]; skipped: number }>> {
+    try { assertPermission(actor, "catalog:update"); } catch (error) { return Err(toCommerceError(error)); }
+    const entity = await this.repo.findEntityById(entityId, ctx);
+    if (!entity) return Err(new CommerceNotFoundError("Entity not found."));
+    try { this.assertSameOrg(entity, actor); } catch (error) { return Err(toCommerceError(error)); }
+
+    const axisValueIds = await this.upsertAxes(entityId, input.axes, ctx);
+    // Empty axis list → one option-less variant.
+    const groups = input.axes.map((axis) =>
+      axis.values.map((value) => ({ value, id: axisValueIds.get(axis.name)!.get(value)! })),
+    );
+    const combinations = cartesian(groups);
+
+    const existing = await this.existingComboKeys(entityId, ctx);
+    const created: Variant[] = [];
+    let skipped = 0;
+    for (const combo of combinations) {
+      const key = combo.map((c) => c.id).sort().join("|");
+      if (existing.has(key)) {
+        skipped += 1;
+        continue;
+      }
+      const sku = input.skuPrefix !== undefined
+        ? [input.skuPrefix, ...combo.map((c) => c.value)].join("-").toUpperCase().replace(/\s+/g, "-")
+        : undefined;
+      const variant = await this.repo.createVariant(
+        {
+          entityId,
+          status: "active",
+          sortOrder: 0,
+          metadata: { generatedBy: "bulk" },
+          ...(sku !== undefined ? { sku } : {}),
+        },
+        ctx,
+      );
+      await this.repo.createVariantOptionValues(
+        combo.map((c) => ({ variantId: variant.id, optionValueId: c.id })),
+        ctx,
+      );
+      const seeded = await this.seedInventoryLevel(entityId, variant.id, actor, ctx);
+      if (!seeded.ok) return seeded;
+      existing.set(key, variant.id);
+      created.push(variant);
+    }
+    return Ok({ created, skipped });
+  }
 }

package/src/modules/catalog/schema.ts

@@ -25,6 +25,9 @@ export const sellableEntities = pgTable(
       .notNull()
       .default("draft"),
     isVisible: boolean("is_visible").notNull().default(false),
+    // Tax class name (issue #57) — maps to tax_classes.name at checkout;
+    // a variant-level taxClass overrides this. Null = the org's default class.
+    taxClass: text("tax_class"),
     metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
     createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
@@ -183,6 +186,8 @@ export const variants = pgTable("variants", {
     .notNull(),
   sku: text("sku").unique(),
   barcode: text("barcode"),
+  // Overrides the entity's taxClass when set (issue #57).
+  taxClass: text("tax_class"),
   status: text("status", { enum: ["active", "discontinued"] })
     .notNull()
     .default("active"),

package/src/modules/catalog/schemas.ts

@@ -6,6 +6,7 @@ export const CreateEntityBodySchema = z.object({
   type: z.string().openapi({ example: "physicalGood" }),
   slug: z.string().openapi({ example: "my-product" }),
   status: z.string().optional().openapi({ example: "draft" }),
+  taxClass: z.string().optional().openapi({ example: "standard", description: "Product tax class name (issue #57)." }),
   basePrice: z.number().optional().openapi({ example: 29.99 }),
   currency: z.string().optional().openapi({ example: "USD" }),
   metadata: z.record(z.string(), z.unknown()).optional().openapi({ example: { title: "My Product" } }),
@@ -24,6 +25,7 @@ export const CreateEntityBodySchema = z.object({
 export const UpdateEntityBodySchema = z.object({
   slug: z.string().optional(),
   status: z.string().optional(),
+  taxClass: z.string().nullable().optional(),
   metadata: z.record(z.string(), z.unknown()).optional(),
   isVisible: z.boolean().optional(),
 }).openapi("UpdateEntityBody");
@@ -69,9 +71,24 @@ export const CreateVariantBodySchema = z.object({
   sku: z.string().optional().openapi({ example: "SKU-001" }),
   options: z.record(z.string(), z.string()).openapi({ example: { Color: "Red" } }),
   price: z.number().optional().openapi({ example: 34.99 }),
+  taxClass: z.string().optional().openapi({ example: "zero", description: "Overrides the entity's tax class (issue #57)." }),
 }).openapi("CreateVariantBody");
 
-export const GenerateVariantsBodySchema = z.object({}).passthrough().openapi("GenerateVariantsBody");
+const VariantMatrixRuleSchema = z.object({
+  include: z.array(z.array(z.string())).optional().openapi({ example: [["red", "small"]] }),
+  exclude: z.array(z.array(z.string())).optional().openapi({ example: [["red", "large"]] }),
+});
+
+export const GenerateVariantsBodySchema = z
+  .discriminatedUnion("mode", [
+    z.object({ mode: z.literal("all") }),
+    z.object({
+      mode: z.literal("manual"),
+      combinations: z.array(z.array(z.string())).openapi({ example: [["red", "small"]] }),
+    }),
+    z.object({ mode: z.literal("matrix"), matrix: VariantMatrixRuleSchema }),
+  ])
+  .openapi("GenerateVariantsBody");
 
 // ─── Derived Input Types ─────────────────────────────────────────────────────
 

package/src/modules/catalog/service.ts

@@ -105,8 +105,8 @@ export interface CatalogEntityHydrated extends SellableEntity {
   optionTypes?: Array<OptionType & { values: OptionValue[] }>;
   categories?: EntityCategory[];
   brands?: EntityBrand[];
-  media?: Array<{ mediaAssetId: string; role: string; variantId?: string }>;
-  pricing?: Array<{ currency: string; amount: number; compareAtAmount?: number | null }>;
+  media?: Array<{ mediaAssetId: string; role: string; sortOrder: number; variantId: string | null; url: string; alt: string | null; contentType: string }>;
+  pricing?: Array<{ id: string; currency: string; amount: number; compareAtAmount?: number | null; createdAt: Date }>;
 }
 
 export interface CatalogService {
@@ -259,6 +259,18 @@ export interface CatalogService {
     actor: Actor | null,
     ctx?: TxContext,
   ): Promise<Result<Variant[]>>;
+  quickCreateVariant(
+    entityId: string,
+    input: { options: Record<string, string>; sku?: string | undefined; barcode?: string | undefined },
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ variant: Variant; created: boolean }>>;
+  bulkCreateVariants(
+    entityId: string,
+    input: { axes: Array<{ name: string; values: string[] }>; skuPrefix?: string | undefined },
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ created: Variant[]; skipped: number }>>;
 }
 
 export interface CatalogServiceDeps {
@@ -411,4 +423,22 @@ export class CatalogServiceImpl implements CatalogService {
   generateVariants(entityId: string, strategy: VariantGenerationStrategy, actor: Actor | null, ctx?: TxContext): Promise<Result<Variant[]>> {
     return this.entities.generateVariants(entityId, strategy, actor, ctx);
   }
+
+  quickCreateVariant(
+    entityId: string,
+    input: { options: Record<string, string>; sku?: string | undefined; barcode?: string | undefined },
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ variant: Variant; created: boolean }>> {
+    return this.entities.quickCreateVariant(entityId, input, actor, ctx);
+  }
+
+  bulkCreateVariants(
+    entityId: string,
+    input: { axes: Array<{ name: string; values: string[] }>; skuPrefix?: string | undefined },
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ created: Variant[]; skipped: number }>> {
+    return this.entities.bulkCreateVariants(entityId, input, actor, ctx);
+  }
 }

package/src/modules/documents/module.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDatabase } from "../../kernel/database/drizzle-db.js";
+import { defineModule } from "../../kernel/module/index.js";
+import { DocumentsRepository } from "./repository/index.js";
+import { invoiceSequences, orderDocuments } from "./schema.js";
+import { DocumentsService } from "./service.js";
+
+export const documentsModule = defineModule<
+  { invoiceSequences: typeof invoiceSequences; orderDocuments: typeof orderDocuments },
+  DocumentsService,
+  Record<string, never>
+>({
+  id: "documents",
+  schema: () => ({ invoiceSequences, orderDocuments }),
+  service: (deps) =>
+    new DocumentsService({
+      repository: new DocumentsRepository(deps.db.db as DrizzleDatabase),
+      services: deps.services as Record<string, unknown>,
+    }),
+});

package/src/modules/documents/pdf.ts

@@ -0,0 +1,101 @@
+/**
+ * Minimal dependency-free PDF writer (issue #47).
+ *
+ * Emits PDF 1.4 with Helvetica / Helvetica-Bold (built-in base-14 fonts, no
+ * embedding) and uncompressed content streams. Pure string/Uint8Array work —
+ * no Node-only APIs, so it runs on Cloudflare Workers and other serverless
+ * runtimes. Enough for text documents like invoices; not a general renderer.
+ */
+
+export interface PdfTextOp {
+  x: number;
+  y: number;
+  size: number;
+  bold?: boolean | undefined;
+  text: string;
+}
+
+/** A4 in PDF points. */
+export const A4 = { width: 595.28, height: 841.89 } as const;
+
+// Escape to a PDF literal string: backslash, parens, and non-ASCII bytes as
+// octal escapes (Latin-1 / WinAnsi range; anything beyond becomes "?").
+function escapePdfText(text: string): string {
+  let out = "";
+  for (const ch of text) {
+    const code = ch.codePointAt(0)!;
+    if (ch === "\\" || ch === "(" || ch === ")") out += `\\${ch}`;
+    else if (code >= 32 && code <= 126) out += ch;
+    else if (code > 126 && code <= 255) out += `\\${code.toString(8).padStart(3, "0")}`;
+    else out += "?";
+  }
+  return out;
+}
+
+function contentStream(ops: PdfTextOp[]): string {
+  const parts: string[] = [];
+  for (const op of ops) {
+    const font = op.bold ? "/F2" : "/F1";
+    parts.push(
+      `BT ${font} ${op.size} Tf ${op.x.toFixed(2)} ${op.y.toFixed(2)} Td (${escapePdfText(op.text)}) Tj ET`,
+    );
+  }
+  return parts.join("\n");
+}
+
+/**
+ * Builds a complete PDF document; one inner array of text ops per page.
+ */
+export function buildPdf(pages: PdfTextOp[][]): Uint8Array {
+  // Object numbering: 1 Catalog, 2 Pages, 3 F1, 4 F2, then per page: Page, Contents.
+  const objects: string[] = [];
+  const pageObjectNumbers: number[] = [];
+  const firstPageObj = 5;
+
+  for (let i = 0; i < pages.length; i++) {
+    pageObjectNumbers.push(firstPageObj + i * 2);
+  }
+
+  objects.push(`1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n`);
+  objects.push(
+    `2 0 obj\n<< /Type /Pages /Kids [${pageObjectNumbers.map((n) => `${n} 0 R`).join(" ")}] /Count ${pages.length} >>\nendobj\n`,
+  );
+  objects.push(`3 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>\nendobj\n`);
+  objects.push(`4 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>\nendobj\n`);
+
+  for (let i = 0; i < pages.length; i++) {
+    const pageNum = pageObjectNumbers[i]!;
+    const contentNum = pageNum + 1;
+    const stream = contentStream(pages[i]!);
+    objects.push(
+      `${pageNum} 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${A4.width} ${A4.height}] ` +
+        `/Resources << /Font << /F1 3 0 R /F2 4 0 R >> >> /Contents ${contentNum} 0 R >>\nendobj\n`,
+    );
+    objects.push(
+      `${contentNum} 0 obj\n<< /Length ${stream.length} >>\nstream\n${stream}\nendstream\nendobj\n`,
+    );
+  }
+
+  const header = "%PDF-1.4\n";
+  let body = header;
+  const offsets: number[] = [];
+  for (const obj of objects) {
+    offsets.push(body.length);
+    body += obj;
+  }
+
+  const xrefOffset = body.length;
+  const count = objects.length + 1;
+  let xref = `xref\n0 ${count}\n0000000000 65535 f \n`;
+  for (const offset of offsets) {
+    xref += `${offset.toString().padStart(10, "0")} 00000 n \n`;
+  }
+  const trailer = `trailer\n<< /Size ${count} /Root 1 0 R >>\nstartxref\n${xrefOffset}\n%%EOF\n`;
+
+  const full = body + xref + trailer;
+  // All bytes are ASCII/Latin-1 by construction (escapePdfText), so a
+  // byte-per-char encoding is exact.
+  const bytes = new Uint8Array(full.length);
+  for (let i = 0; i < full.length; i++) bytes[i] = full.charCodeAt(i) & 0xff;
+  return bytes;
+}