@voyantjs/catalog-authoring 0.105.0 → 0.106.1

package/dist/clone-content.d.ts

@@ -0,0 +1,38 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+/** Shared, mutable state threaded across the clone copy phases (id remaps). */
+export interface CloneContext {
+    tx: PostgresJsDatabase;
+    sourceId: string;
+    targetId: string;
+    copyDepartures: boolean;
+    optionIdMap: Map<string, string>;
+    unitIdMap: Map<string, string>;
+    unitsByNewOption: Map<string, {
+        id: string;
+    }[]>;
+    itineraryIdMap: Map<string, string>;
+    dayIdMap: Map<string, string>;
+    startTimeIdMap: Map<string, string>;
+    ruleIdMap: Map<string, string>;
+    slotIdMap: Map<string, string>;
+    optionPriceRuleIdMap: Map<string, string>;
+    optionUnitPriceRuleIdMap: Map<string, string>;
+    pricingCategoryIdMap: Map<string, string>;
+    productExtraIdMap: Map<string, string>;
+    optionExtraConfigIdMap: Map<string, string>;
+}
+type SystemColumns = {
+    id?: unknown;
+    createdAt?: unknown;
+    updatedAt?: unknown;
+};
+export declare function withoutSystemColumns<T extends SystemColumns>(row: T): Omit<T, "id" | "createdAt" | "updatedAt">;
+/**
+ * Copies the product's content graph: per-product settings, options + units
+ * (with translations + resource templates), pricing categories (+ dependencies,
+ * remapped), itineraries/days/services, media, and extras. Populates the id
+ * remaps in {@link CloneContext} for the pricing/availability phase.
+ */
+export declare function copyProductContent(ctx: CloneContext): Promise<void>;
+export {};
+//# sourceMappingURL=clone-content.d.ts.map

package/dist/clone-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-content.d.ts","sourceRoot":"","sources":["../src/clone-content.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,kBAAkB,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,OAAO,CAAA;IACvB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAA;IAC/C,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7C,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC5C;AAED,KAAK,aAAa,GAAG;IACnB,EAAE,CAAC,EAAE,OAAO,CAAA;IACZ,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,aAAa,EAAE,GAAG,EAAE,CAAC,6CAGnE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA6HzE"}

package/dist/clone-content.js

@@ -0,0 +1,367 @@
+import { productOptionResourceTemplates } from "@voyantjs/availability";
+import { optionExtraConfigs, productExtras } from "@voyantjs/extras";
+import { pricingCategories, pricingCategoryDependencies } from "@voyantjs/pricing/schema";
+import { optionUnits, optionUnitTranslations, productActivationSettings, productCapabilities, productCategoryProducts, productDayServices, productDays, productDayTranslations, productDeliveryFormats, productDestinations, productFaqs, productFeatures, productItineraries, productLocations, productMedia, productOptions, productOptionTranslations, productTagProducts, productTicketSettings, productTranslations, productVisibilitySettings, } from "@voyantjs/products/schema";
+import { eq, inArray } from "drizzle-orm";
+export function withoutSystemColumns(row) {
+    const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...values } = row;
+    return values;
+}
+/**
+ * Copies the product's content graph: per-product settings, options + units
+ * (with translations + resource templates), pricing categories (+ dependencies,
+ * remapped), itineraries/days/services, media, and extras. Populates the id
+ * remaps in {@link CloneContext} for the pricing/availability phase.
+ */
+export async function copyProductContent(ctx) {
+    const { tx, sourceId, targetId } = ctx;
+    const activationRows = await tx
+        .select()
+        .from(productActivationSettings)
+        .where(eq(productActivationSettings.productId, sourceId));
+    for (const row of activationRows) {
+        await tx.insert(productActivationSettings).values({
+            ...withoutSystemColumns(row),
+            productId: targetId,
+            activationMode: "manual",
+            activateAt: null,
+            deactivateAt: null,
+            sellAt: null,
+            stopSellAt: null,
+        });
+    }
+    const ticketRows = await tx
+        .select()
+        .from(productTicketSettings)
+        .where(eq(productTicketSettings.productId, sourceId));
+    for (const row of ticketRows) {
+        await tx
+            .insert(productTicketSettings)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const visibilityRows = await tx
+        .select()
+        .from(productVisibilitySettings)
+        .where(eq(productVisibilitySettings.productId, sourceId));
+    for (const row of visibilityRows) {
+        await tx
+            .insert(productVisibilitySettings)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const capabilityRows = await tx
+        .select()
+        .from(productCapabilities)
+        .where(eq(productCapabilities.productId, sourceId));
+    for (const row of capabilityRows) {
+        await tx
+            .insert(productCapabilities)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const deliveryFormatRows = await tx
+        .select()
+        .from(productDeliveryFormats)
+        .where(eq(productDeliveryFormats.productId, sourceId));
+    for (const row of deliveryFormatRows) {
+        await tx
+            .insert(productDeliveryFormats)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const featureRows = await tx
+        .select()
+        .from(productFeatures)
+        .where(eq(productFeatures.productId, sourceId));
+    for (const row of featureRows) {
+        await tx.insert(productFeatures).values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const faqRows = await tx.select().from(productFaqs).where(eq(productFaqs.productId, sourceId));
+    for (const row of faqRows) {
+        await tx.insert(productFaqs).values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const locationRows = await tx
+        .select()
+        .from(productLocations)
+        .where(eq(productLocations.productId, sourceId));
+    for (const row of locationRows) {
+        await tx.insert(productLocations).values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const translationRows = await tx
+        .select()
+        .from(productTranslations)
+        .where(eq(productTranslations.productId, sourceId));
+    for (const row of translationRows) {
+        await tx
+            .insert(productTranslations)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const categoryRows = await tx
+        .select()
+        .from(productCategoryProducts)
+        .where(eq(productCategoryProducts.productId, sourceId));
+    for (const row of categoryRows) {
+        await tx
+            .insert(productCategoryProducts)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const tagRows = await tx
+        .select()
+        .from(productTagProducts)
+        .where(eq(productTagProducts.productId, sourceId));
+    for (const row of tagRows) {
+        await tx
+            .insert(productTagProducts)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    const destinationRows = await tx
+        .select()
+        .from(productDestinations)
+        .where(eq(productDestinations.productId, sourceId));
+    for (const row of destinationRows) {
+        await tx
+            .insert(productDestinations)
+            .values({ ...withoutSystemColumns(row), productId: targetId });
+    }
+    await copyOptionsAndUnits(ctx);
+    await copyPricingCategories(ctx);
+    await copyItinerary(ctx);
+    await copyMedia(ctx);
+    await copyExtras(ctx);
+}
+async function copyOptionsAndUnits(ctx) {
+    const { tx, sourceId, targetId, optionIdMap, unitIdMap, unitsByNewOption } = ctx;
+    const sourceOptions = await tx
+        .select()
+        .from(productOptions)
+        .where(eq(productOptions.productId, sourceId));
+    for (const row of sourceOptions) {
+        const [copy] = await tx
+            .insert(productOptions)
+            .values({ ...withoutSystemColumns(row), productId: targetId })
+            .returning();
+        if (copy) {
+            optionIdMap.set(row.id, copy.id);
+            unitsByNewOption.set(copy.id, []);
+        }
+    }
+    const sourceOptionIds = sourceOptions.map((row) => row.id);
+    if (sourceOptionIds.length === 0)
+        return;
+    const optionTranslationRows = await tx
+        .select()
+        .from(productOptionTranslations)
+        .where(inArray(productOptionTranslations.optionId, sourceOptionIds));
+    for (const row of optionTranslationRows) {
+        const targetOptionId = optionIdMap.get(row.optionId);
+        if (!targetOptionId)
+            continue;
+        await tx
+            .insert(productOptionTranslations)
+            .values({ ...withoutSystemColumns(row), optionId: targetOptionId });
+    }
+    const sourceUnits = await tx
+        .select()
+        .from(optionUnits)
+        .where(inArray(optionUnits.optionId, sourceOptionIds));
+    for (const row of sourceUnits) {
+        const targetOptionId = optionIdMap.get(row.optionId);
+        if (!targetOptionId)
+            continue;
+        const [copy] = await tx
+            .insert(optionUnits)
+            .values({ ...withoutSystemColumns(row), optionId: targetOptionId })
+            .returning();
+        if (copy) {
+            unitIdMap.set(row.id, copy.id);
+            unitsByNewOption.get(targetOptionId)?.push({ id: copy.id });
+        }
+    }
+    const sourceUnitIds = sourceUnits.map((row) => row.id);
+    if (sourceUnitIds.length > 0) {
+        const unitTranslationRows = await tx
+            .select()
+            .from(optionUnitTranslations)
+            .where(inArray(optionUnitTranslations.unitId, sourceUnitIds));
+        for (const row of unitTranslationRows) {
+            const targetUnitId = unitIdMap.get(row.unitId);
+            if (!targetUnitId)
+                continue;
+            await tx
+                .insert(optionUnitTranslations)
+                .values({ ...withoutSystemColumns(row), unitId: targetUnitId });
+        }
+    }
+    const resourceTemplateRows = await tx
+        .select()
+        .from(productOptionResourceTemplates)
+        .where(inArray(productOptionResourceTemplates.productOptionId, sourceOptionIds));
+    for (const row of resourceTemplateRows) {
+        const targetOptionId = optionIdMap.get(row.productOptionId);
+        if (!targetOptionId)
+            continue;
+        await tx
+            .insert(productOptionResourceTemplates)
+            .values({ ...withoutSystemColumns(row), productOptionId: targetOptionId });
+    }
+}
+async function copyPricingCategories(ctx) {
+    const { tx, sourceId, targetId, optionIdMap, unitIdMap, pricingCategoryIdMap } = ctx;
+    const pricingCategoryRows = await tx
+        .select()
+        .from(pricingCategories)
+        .where(eq(pricingCategories.productId, sourceId));
+    for (const row of pricingCategoryRows) {
+        const targetOptionId = row.optionId ? (optionIdMap.get(row.optionId) ?? null) : null;
+        const targetUnitId = row.unitId ? (unitIdMap.get(row.unitId) ?? null) : null;
+        if (row.optionId && !targetOptionId)
+            continue;
+        if (row.unitId && !targetUnitId)
+            continue;
+        const [copy] = await tx
+            .insert(pricingCategories)
+            .values({
+            ...withoutSystemColumns(row),
+            productId: targetId,
+            optionId: targetOptionId,
+            unitId: targetUnitId,
+        })
+            .returning();
+        if (copy)
+            pricingCategoryIdMap.set(row.id, copy.id);
+    }
+    const sourcePricingCategoryIds = pricingCategoryRows.map((row) => row.id);
+    if (sourcePricingCategoryIds.length === 0)
+        return;
+    const dependencyRows = await tx
+        .select()
+        .from(pricingCategoryDependencies)
+        .where(inArray(pricingCategoryDependencies.pricingCategoryId, sourcePricingCategoryIds));
+    for (const row of dependencyRows) {
+        const targetPricingCategoryId = pricingCategoryIdMap.get(row.pricingCategoryId);
+        const targetMasterPricingCategoryId = pricingCategoryIdMap.get(row.masterPricingCategoryId);
+        if (!targetPricingCategoryId || !targetMasterPricingCategoryId)
+            continue;
+        await tx.insert(pricingCategoryDependencies).values({
+            ...withoutSystemColumns(row),
+            pricingCategoryId: targetPricingCategoryId,
+            masterPricingCategoryId: targetMasterPricingCategoryId,
+        });
+    }
+}
+async function copyItinerary(ctx) {
+    const { tx, sourceId, targetId, itineraryIdMap, dayIdMap } = ctx;
+    const sourceItineraries = await tx
+        .select()
+        .from(productItineraries)
+        .where(eq(productItineraries.productId, sourceId));
+    for (const row of sourceItineraries) {
+        const [copy] = await tx
+            .insert(productItineraries)
+            .values({ ...withoutSystemColumns(row), productId: targetId })
+            .returning();
+        if (copy)
+            itineraryIdMap.set(row.id, copy.id);
+    }
+    if (sourceItineraries.length === 0) {
+        await tx
+            .insert(productItineraries)
+            .values({ productId: targetId, name: "Default", isDefault: true, sortOrder: 0 });
+        return;
+    }
+    const sourceItineraryIds = sourceItineraries.map((row) => row.id);
+    const sourceDays = await tx
+        .select()
+        .from(productDays)
+        .where(inArray(productDays.itineraryId, sourceItineraryIds));
+    for (const row of sourceDays) {
+        const targetItineraryId = itineraryIdMap.get(row.itineraryId);
+        if (!targetItineraryId)
+            continue;
+        const [copy] = await tx
+            .insert(productDays)
+            .values({ ...withoutSystemColumns(row), itineraryId: targetItineraryId })
+            .returning();
+        if (copy)
+            dayIdMap.set(row.id, copy.id);
+    }
+    const sourceDayIds = sourceDays.map((row) => row.id);
+    if (sourceDayIds.length === 0)
+        return;
+    const dayServiceRows = await tx
+        .select()
+        .from(productDayServices)
+        .where(inArray(productDayServices.dayId, sourceDayIds));
+    for (const row of dayServiceRows) {
+        const targetDayId = dayIdMap.get(row.dayId);
+        if (!targetDayId)
+            continue;
+        await tx.insert(productDayServices).values({ ...withoutSystemColumns(row), dayId: targetDayId });
+    }
+    const dayTranslationRows = await tx
+        .select()
+        .from(productDayTranslations)
+        .where(inArray(productDayTranslations.dayId, sourceDayIds));
+    for (const row of dayTranslationRows) {
+        const targetDayId = dayIdMap.get(row.dayId);
+        if (!targetDayId)
+            continue;
+        await tx
+            .insert(productDayTranslations)
+            .values({ ...withoutSystemColumns(row), dayId: targetDayId });
+    }
+}
+async function copyMedia(ctx) {
+    const { tx, sourceId, targetId, dayIdMap } = ctx;
+    const mediaRows = await tx.select().from(productMedia).where(eq(productMedia.productId, sourceId));
+    for (const row of mediaRows) {
+        if (row.isBrochure)
+            continue;
+        const targetDayId = row.dayId ? dayIdMap.get(row.dayId) : null;
+        if (row.dayId && !targetDayId)
+            continue;
+        await tx.insert(productMedia).values({
+            ...withoutSystemColumns(row),
+            productId: targetId,
+            dayId: targetDayId,
+            isBrochure: false,
+            isBrochureCurrent: false,
+            brochureVersion: null,
+        });
+    }
+}
+async function copyExtras(ctx) {
+    const { tx, sourceId, targetId, optionIdMap, productExtraIdMap, optionExtraConfigIdMap } = ctx;
+    const extraRows = await tx
+        .select()
+        .from(productExtras)
+        .where(eq(productExtras.productId, sourceId));
+    for (const row of extraRows) {
+        const [copy] = await tx
+            .insert(productExtras)
+            .values({ ...withoutSystemColumns(row), productId: targetId })
+            .returning();
+        if (copy)
+            productExtraIdMap.set(row.id, copy.id);
+    }
+    const sourceOptionIds = [...optionIdMap.keys()];
+    if (sourceOptionIds.length === 0)
+        return;
+    const extraConfigRows = await tx
+        .select()
+        .from(optionExtraConfigs)
+        .where(inArray(optionExtraConfigs.optionId, sourceOptionIds));
+    for (const row of extraConfigRows) {
+        const targetOptionId = optionIdMap.get(row.optionId);
+        const targetProductExtraId = productExtraIdMap.get(row.productExtraId);
+        if (!targetOptionId || !targetProductExtraId)
+            continue;
+        const [copy] = await tx
+            .insert(optionExtraConfigs)
+            .values({
+            ...withoutSystemColumns(row),
+            optionId: targetOptionId,
+            productExtraId: targetProductExtraId,
+        })
+            .returning();
+        if (copy)
+            optionExtraConfigIdMap.set(row.id, copy.id);
+    }
+}

package/dist/clone-pricing.d.ts

@@ -0,0 +1,9 @@
+import { type CloneContext } from "./clone-content.js";
+/**
+ * Copies availability (when `copyDepartures`) and the full pricing-rule graph —
+ * option price rules → unit price rules (with remapped pricing categories) →
+ * tiers, plus start-time / pickup / dropoff / extra rules and departure
+ * overrides. Relies on the id remaps populated by {@link copyProductContent}.
+ */
+export declare function copyPricingAndAvailability(ctx: CloneContext): Promise<void>;
+//# sourceMappingURL=clone-pricing.d.ts.map

package/dist/clone-pricing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-pricing.d.ts","sourceRoot":"","sources":["../src/clone-pricing.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,oBAAoB,CAAA;AAE5E;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAQjF"}

package/dist/clone-pricing.js

@@ -0,0 +1,242 @@
+import { availabilityRules, availabilitySlots, availabilityStartTimes, } from "@voyantjs/availability";
+import { departurePriceOverrides, dropoffPriceRules, extraPriceRules, optionPriceRules, optionStartTimeRules, optionUnitPriceRules, optionUnitTiers, pickupPriceRules, } from "@voyantjs/pricing/schema";
+import { eq, inArray } from "drizzle-orm";
+import { withoutSystemColumns } from "./clone-content.js";
+/**
+ * Copies availability (when `copyDepartures`) and the full pricing-rule graph —
+ * option price rules → unit price rules (with remapped pricing categories) →
+ * tiers, plus start-time / pickup / dropoff / extra rules and departure
+ * overrides. Relies on the id remaps populated by {@link copyProductContent}.
+ */
+export async function copyPricingAndAvailability(ctx) {
+    if (ctx.copyDepartures) {
+        await copyAvailability(ctx);
+    }
+    await copyPriceRules(ctx);
+    if (ctx.copyDepartures && ctx.slotIdMap.size > 0) {
+        await copyDepartureOverrides(ctx);
+    }
+}
+async function copyAvailability(ctx) {
+    const { tx, sourceId, targetId, optionIdMap, itineraryIdMap, startTimeIdMap, ruleIdMap, slotIdMap, } = ctx;
+    const startTimeRows = await tx
+        .select()
+        .from(availabilityStartTimes)
+        .where(eq(availabilityStartTimes.productId, sourceId));
+    for (const row of startTimeRows) {
+        const [copy] = await tx
+            .insert(availabilityStartTimes)
+            .values({
+            ...withoutSystemColumns(row),
+            productId: targetId,
+            optionId: row.optionId ? (optionIdMap.get(row.optionId) ?? null) : null,
+        })
+            .returning();
+        if (copy)
+            startTimeIdMap.set(row.id, copy.id);
+    }
+    const availabilityRuleRows = await tx
+        .select()
+        .from(availabilityRules)
+        .where(eq(availabilityRules.productId, sourceId));
+    for (const row of availabilityRuleRows) {
+        const [copy] = await tx
+            .insert(availabilityRules)
+            .values({
+            ...withoutSystemColumns(row),
+            productId: targetId,
+            optionId: row.optionId ? (optionIdMap.get(row.optionId) ?? null) : null,
+        })
+            .returning();
+        if (copy)
+            ruleIdMap.set(row.id, copy.id);
+    }
+    const slotRows = await tx
+        .select()
+        .from(availabilitySlots)
+        .where(eq(availabilitySlots.productId, sourceId));
+    for (const row of slotRows) {
+        const targetItineraryId = row.itineraryId ? (itineraryIdMap.get(row.itineraryId) ?? null) : null;
+        const targetOptionId = row.optionId ? (optionIdMap.get(row.optionId) ?? null) : null;
+        const targetRuleId = row.availabilityRuleId
+            ? (ruleIdMap.get(row.availabilityRuleId) ?? null)
+            : null;
+        const targetStartTimeId = row.startTimeId ? (startTimeIdMap.get(row.startTimeId) ?? null) : null;
+        const [copy] = await tx
+            .insert(availabilitySlots)
+            .values({
+            ...withoutSystemColumns(row),
+            productId: targetId,
+            itineraryId: targetItineraryId,
+            optionId: targetOptionId,
+            availabilityRuleId: targetRuleId,
+            startTimeId: targetStartTimeId,
+            remainingPax: row.initialPax,
+            remainingPickups: row.initialPickups,
+        })
+            .returning();
+        if (copy)
+            slotIdMap.set(row.id, copy.id);
+    }
+}
+async function copyPriceRules(ctx) {
+    const { tx, targetId, optionIdMap, unitIdMap, startTimeIdMap, optionPriceRuleIdMap, optionUnitPriceRuleIdMap, pricingCategoryIdMap, productExtraIdMap, optionExtraConfigIdMap, } = ctx;
+    const sourceOptionIds = [...optionIdMap.keys()];
+    if (sourceOptionIds.length === 0)
+        return;
+    const optionPriceRuleRows = await tx
+        .select()
+        .from(optionPriceRules)
+        .where(inArray(optionPriceRules.optionId, sourceOptionIds));
+    for (const row of optionPriceRuleRows) {
+        const targetOptionId = optionIdMap.get(row.optionId);
+        if (!targetOptionId)
+            continue;
+        const [copy] = await tx
+            .insert(optionPriceRules)
+            .values({ ...withoutSystemColumns(row), productId: targetId, optionId: targetOptionId })
+            .returning();
+        if (copy)
+            optionPriceRuleIdMap.set(row.id, copy.id);
+    }
+    const sourceOptionPriceRuleIds = optionPriceRuleRows.map((row) => row.id);
+    if (sourceOptionPriceRuleIds.length === 0)
+        return;
+    const optionUnitPriceRuleRows = await tx
+        .select()
+        .from(optionUnitPriceRules)
+        .where(inArray(optionUnitPriceRules.optionPriceRuleId, sourceOptionPriceRuleIds));
+    for (const row of optionUnitPriceRuleRows) {
+        const targetPriceRuleId = optionPriceRuleIdMap.get(row.optionPriceRuleId);
+        const targetOptionId = optionIdMap.get(row.optionId);
+        const targetUnitId = unitIdMap.get(row.unitId);
+        const targetPricingCategoryId = row.pricingCategoryId
+            ? (pricingCategoryIdMap.get(row.pricingCategoryId) ?? null)
+            : null;
+        if (!targetPriceRuleId || !targetOptionId || !targetUnitId)
+            continue;
+        if (row.pricingCategoryId && !targetPricingCategoryId)
+            continue;
+        const [copy] = await tx
+            .insert(optionUnitPriceRules)
+            .values({
+            ...withoutSystemColumns(row),
+            optionPriceRuleId: targetPriceRuleId,
+            optionId: targetOptionId,
+            unitId: targetUnitId,
+            pricingCategoryId: targetPricingCategoryId,
+        })
+            .returning();
+        if (copy)
+            optionUnitPriceRuleIdMap.set(row.id, copy.id);
+    }
+    const sourceOptionUnitPriceRuleIds = optionUnitPriceRuleRows.map((row) => row.id);
+    if (sourceOptionUnitPriceRuleIds.length > 0) {
+        const tierRows = await tx
+            .select()
+            .from(optionUnitTiers)
+            .where(inArray(optionUnitTiers.optionUnitPriceRuleId, sourceOptionUnitPriceRuleIds));
+        for (const row of tierRows) {
+            const targetUnitPriceRuleId = optionUnitPriceRuleIdMap.get(row.optionUnitPriceRuleId);
+            if (!targetUnitPriceRuleId)
+                continue;
+            await tx
+                .insert(optionUnitTiers)
+                .values({ ...withoutSystemColumns(row), optionUnitPriceRuleId: targetUnitPriceRuleId });
+        }
+    }
+    const startRuleRows = await tx
+        .select()
+        .from(optionStartTimeRules)
+        .where(inArray(optionStartTimeRules.optionPriceRuleId, sourceOptionPriceRuleIds));
+    for (const row of startRuleRows) {
+        const targetPriceRuleId = optionPriceRuleIdMap.get(row.optionPriceRuleId);
+        const targetOptionId = optionIdMap.get(row.optionId);
+        const targetStartTimeId = startTimeIdMap.get(row.startTimeId);
+        if (!targetPriceRuleId || !targetOptionId || !targetStartTimeId)
+            continue;
+        await tx.insert(optionStartTimeRules).values({
+            ...withoutSystemColumns(row),
+            optionPriceRuleId: targetPriceRuleId,
+            optionId: targetOptionId,
+            startTimeId: targetStartTimeId,
+        });
+    }
+    const pickupPriceRuleRows = await tx
+        .select()
+        .from(pickupPriceRules)
+        .where(inArray(pickupPriceRules.optionPriceRuleId, sourceOptionPriceRuleIds));
+    for (const row of pickupPriceRuleRows) {
+        const targetPriceRuleId = optionPriceRuleIdMap.get(row.optionPriceRuleId);
+        const targetOptionId = optionIdMap.get(row.optionId);
+        if (!targetPriceRuleId || !targetOptionId)
+            continue;
+        await tx.insert(pickupPriceRules).values({
+            ...withoutSystemColumns(row),
+            optionPriceRuleId: targetPriceRuleId,
+            optionId: targetOptionId,
+        });
+    }
+    const dropoffPriceRuleRows = await tx
+        .select()
+        .from(dropoffPriceRules)
+        .where(inArray(dropoffPriceRules.optionPriceRuleId, sourceOptionPriceRuleIds));
+    for (const row of dropoffPriceRuleRows) {
+        const targetPriceRuleId = optionPriceRuleIdMap.get(row.optionPriceRuleId);
+        const targetOptionId = optionIdMap.get(row.optionId);
+        if (!targetPriceRuleId || !targetOptionId)
+            continue;
+        await tx.insert(dropoffPriceRules).values({
+            ...withoutSystemColumns(row),
+            optionPriceRuleId: targetPriceRuleId,
+            optionId: targetOptionId,
+        });
+    }
+    const extraPriceRuleRows = await tx
+        .select()
+        .from(extraPriceRules)
+        .where(inArray(extraPriceRules.optionPriceRuleId, sourceOptionPriceRuleIds));
+    for (const row of extraPriceRuleRows) {
+        const targetPriceRuleId = optionPriceRuleIdMap.get(row.optionPriceRuleId);
+        const targetOptionId = optionIdMap.get(row.optionId);
+        const targetProductExtraId = row.productExtraId
+            ? (productExtraIdMap.get(row.productExtraId) ?? null)
+            : null;
+        const targetOptionExtraConfigId = row.optionExtraConfigId
+            ? (optionExtraConfigIdMap.get(row.optionExtraConfigId) ?? null)
+            : null;
+        if (!targetPriceRuleId || !targetOptionId)
+            continue;
+        if (row.productExtraId && !targetProductExtraId)
+            continue;
+        if (row.optionExtraConfigId && !targetOptionExtraConfigId)
+            continue;
+        await tx.insert(extraPriceRules).values({
+            ...withoutSystemColumns(row),
+            optionPriceRuleId: targetPriceRuleId,
+            optionId: targetOptionId,
+            productExtraId: targetProductExtraId,
+            optionExtraConfigId: targetOptionExtraConfigId,
+        });
+    }
+}
+async function copyDepartureOverrides(ctx) {
+    const { tx, optionIdMap, unitIdMap, slotIdMap } = ctx;
+    const overrideRows = await tx
+        .select()
+        .from(departurePriceOverrides)
+        .where(inArray(departurePriceOverrides.departureId, [...slotIdMap.keys()]));
+    for (const row of overrideRows) {
+        const targetDepartureId = slotIdMap.get(row.departureId);
+        const targetOptionId = optionIdMap.get(row.optionId);
+        const targetUnitId = unitIdMap.get(row.optionUnitId);
+        if (!targetDepartureId || !targetOptionId || !targetUnitId)
+            continue;
+        await tx.insert(departurePriceOverrides).values({
+            ...withoutSystemColumns(row),
+            departureId: targetDepartureId,
+            optionId: targetOptionId,
+            optionUnitId: targetUnitId,
+        });
+    }
+}

package/dist/clone.d.ts

@@ -0,0 +1,45 @@
+import { products } from "@voyantjs/products/schema";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+type Product = typeof products.$inferSelect;
+export interface CloneProductOptions {
+    /** New product name. Defaults to `"{source} (Copy)"` (preserves the UI's no-body call). */
+    name?: string;
+    /** New product status. Defaults to `draft`. */
+    status?: Product["status"];
+    /** New product visibility. Defaults to the source's. */
+    visibility?: Product["visibility"];
+    /**
+     * Copy availability slots/rules/start-times + departure price overrides.
+     * Defaults to `true` (the operator UI clones a full working copy). The Max AI
+     * agent passes `false` per #1493 — departures are date-specific, so the clone
+     * starts with none and the agent adds fresh ones.
+     */
+    copyDepartures?: boolean;
+    /** Author of the initial `product_versions` snapshot. When omitted, no snapshot is taken. */
+    userId?: string;
+    /** Dedup key; a retried request with the same key returns the first clone. */
+    idempotencyKey?: string;
+}
+export interface ClonedOption {
+    id: string;
+    units: {
+        id: string;
+    }[];
+}
+export type CloneProductOutcome = {
+    status: "ok";
+    product: Product;
+    options: ClonedOption[];
+    reused: boolean;
+} | {
+    status: "not_found";
+};
+/**
+ * Deep-clone a product (#1493). Wraps {@link cloneGraph} with idempotency and an
+ * optional `product_versions` snapshot. The operator UI calls this with no
+ * overrides (full copy, `"{X} (Copy)"`, departures included); the agent passes
+ * `name` + `copyDepartures: false` + an `Idempotency-Key`.
+ */
+export declare function cloneProduct(db: PostgresJsDatabase, sourceProductId: string, options?: CloneProductOptions): Promise<CloneProductOutcome>;
+export {};
+//# sourceMappingURL=clone.d.ts.map

package/dist/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../src/clone.ts"],"names":[],"mappings":"AACA,OAAO,EAA+B,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAEjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAKjE,KAAK,OAAO,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAE3C,MAAM,WAAW,mBAAmB;IAClC,2FAA2F;IAC3F,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,+CAA+C;IAC/C,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC1B,wDAAwD;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;IAClC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CACxB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC5E;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,CAAA;AA+G3B;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,kBAAkB,EACtB,eAAe,EAAE,MAAM,EACvB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,mBAAmB,CAAC,CAoD9B"}

package/dist/clone.js

@@ -0,0 +1,141 @@
+import { productsService } from "@voyantjs/products";
+import { optionUnits, productOptions, products } from "@voyantjs/products/schema";
+import { eq, inArray, sql } from "drizzle-orm";
+import { copyProductContent, withoutSystemColumns } from "./clone-content.js";
+import { copyPricingAndAvailability } from "./clone-pricing.js";
+import { productAuthoringRequests } from "./schema.js";
+function copyName(name) {
+    return `${name} (Copy)`;
+}
+/**
+ * Reads a product's options + units back into the {@link ClonedOption} shape.
+ * Used to reconstruct the result for an idempotent retry, so a re-sent clone
+ * returns the same option/unit ids a fresh response would (the agent needs them
+ * to continue authoring after the exact lost-response case idempotency covers).
+ */
+async function loadClonedOptions(tx, productId) {
+    const optionRows = await tx
+        .select({ id: productOptions.id })
+        .from(productOptions)
+        .where(eq(productOptions.productId, productId));
+    if (optionRows.length === 0)
+        return [];
+    const unitRows = await tx
+        .select({ id: optionUnits.id, optionId: optionUnits.optionId })
+        .from(optionUnits)
+        .where(inArray(optionUnits.optionId, optionRows.map((o) => o.id)));
+    return optionRows.map((o) => ({
+        id: o.id,
+        units: unitRows.filter((u) => u.optionId === o.id).map((u) => ({ id: u.id })),
+    }));
+}
+function newContext(tx, sourceId, targetId, copyDepartures) {
+    return {
+        tx,
+        sourceId,
+        targetId,
+        copyDepartures,
+        optionIdMap: new Map(),
+        unitIdMap: new Map(),
+        unitsByNewOption: new Map(),
+        itineraryIdMap: new Map(),
+        dayIdMap: new Map(),
+        startTimeIdMap: new Map(),
+        ruleIdMap: new Map(),
+        slotIdMap: new Map(),
+        optionPriceRuleIdMap: new Map(),
+        optionUnitPriceRuleIdMap: new Map(),
+        pricingCategoryIdMap: new Map(),
+        productExtraIdMap: new Map(),
+        optionExtraConfigIdMap: new Map(),
+    };
+}
+/**
+ * Deep-clone a product graph as a draft (#1493): the new product row, then its
+ * content (options/units, pricing categories, itinerary, media, extras) and its
+ * pricing/availability — copied with correct id remapping. Availability is
+ * copied only when `copyDepartures`. MUST run inside the caller's transaction.
+ */
+async function cloneGraph(tx, sourceId, opts) {
+    const [sourceProduct] = await tx.select().from(products).where(eq(products.id, sourceId));
+    if (!sourceProduct)
+        return null;
+    const [targetProduct] = await tx
+        .insert(products)
+        .values({
+        ...withoutSystemColumns(sourceProduct),
+        name: opts.name ?? copyName(sourceProduct.name),
+        status: opts.status ?? "draft",
+        ...(opts.visibility ? { visibility: opts.visibility } : {}),
+        activated: false,
+    })
+        .returning();
+    if (!targetProduct) {
+        throw new Error("Failed to duplicate product");
+    }
+    const ctx = newContext(tx, sourceId, targetProduct.id, opts.copyDepartures);
+    await copyProductContent(ctx);
+    await copyPricingAndAvailability(ctx);
+    const options = [...ctx.optionIdMap.values()].map((id) => ({
+        id,
+        units: ctx.unitsByNewOption.get(id) ?? [],
+    }));
+    return { product: targetProduct, options };
+}
+/**
+ * Deep-clone a product (#1493). Wraps {@link cloneGraph} with idempotency and an
+ * optional `product_versions` snapshot. The operator UI calls this with no
+ * overrides (full copy, `"{X} (Copy)"`, departures included); the agent passes
+ * `name` + `copyDepartures: false` + an `Idempotency-Key`.
+ */
+export async function cloneProduct(db, sourceProductId, options = {}) {
+    const [exists] = await db
+        .select({ id: products.id })
+        .from(products)
+        .where(eq(products.id, sourceProductId))
+        .limit(1);
+    if (!exists)
+        return { status: "not_found" };
+    const copyDepartures = options.copyDepartures ?? true;
+    const key = options.idempotencyKey;
+    const result = await db.transaction(async (tx) => {
+        if (key) {
+            await tx.execute(sql `SELECT pg_advisory_xact_lock(hashtextextended(${key}, 0))`);
+            const [prev] = await tx
+                .select({ productId: productAuthoringRequests.productId })
+                .from(productAuthoringRequests)
+                .where(eq(productAuthoringRequests.idempotencyKey, key))
+                .limit(1);
+            if (prev) {
+                const [product] = await tx
+                    .select()
+                    .from(products)
+                    .where(eq(products.id, prev.productId))
+                    .limit(1);
+                if (product) {
+                    return { product, options: await loadClonedOptions(tx, product.id), reused: true };
+                }
+            }
+        }
+        const cloned = await cloneGraph(tx, sourceProductId, {
+            name: options.name,
+            status: options.status,
+            visibility: options.visibility,
+            copyDepartures,
+        });
+        if (!cloned)
+            return null;
+        if (options.userId) {
+            await productsService.createVersion(tx, cloned.product.id, options.userId, {});
+        }
+        if (key) {
+            await tx
+                .insert(productAuthoringRequests)
+                .values({ idempotencyKey: key, productId: cloned.product.id, operation: "duplicate" });
+        }
+        return { ...cloned, reused: false };
+    });
+    if (!result)
+        return { status: "not_found" };
+    return { status: "ok", ...result };
+}

package/dist/extension.d.ts

@@ -3,18 +3,17 @@ import type { HonoExtension } from "@voyantjs/hono/module";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 /**
  * Catalog authoring rides on the `products` admin prefix as a HonoExtension, so
- * its route lands at `/v1/admin/products/...` without `packages/products`
+ * its routes land at `/v1/admin/products/...` without `packages/products`
  * depending on this package (which would cycle, since this package depends on
  * both products and pricing). Same mechanism as `bookingsSupplierExtension`.
  *
- *   POST /v1/admin/products/compose — build a new product graph from a spec (#1495)
+ *   POST /v1/admin/products/{id}/duplicate — deep-clone a product graph (#1493)
+ *   POST /v1/admin/products/compose        — build a new product graph from a spec (#1495)
  *
- * NOTE: deep-cloning an existing product (#1493) is deliberately NOT exposed
- * here. The operator template already serves a comprehensive deep-clone at
- * `POST /v1/admin/products/{id}/duplicate` (`duplicateProductAsDraft`); adding a
- * second handler at that path would shadow it. Composing a NEW graph is the
- * genuinely new, non-overlapping capability — it covers the cold-start /
- * never-authored-before case that clone cannot.
+ * The duplicate route is the canonical product clone (it replaces the operator
+ * template's previous local `duplicateProductAsDraft` route). No body → a full
+ * copy named `"{X} (Copy)"` with departures (preserves the UI). The agent passes
+ * `{ name, copyDepartures: false }` + an `Idempotency-Key`.
  */
 type Env = {
     Variables: {
@@ -57,7 +56,82 @@ export declare const catalogAuthoringRoutes: import("hono/hono-base").HonoBase<E
             status: 200 | 201;
         };
     };
-}, "/", "/compose">;
+} & {
+    "/:id/duplicate": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    timezone: string | null;
+                    sellAmountCents: number | null;
+                    costAmountCents: number | null;
+                    description: string | null;
+                    facilityId: string | null;
+                    status: "active" | "draft" | "archived";
+                    startDate: string | null;
+                    endDate: string | null;
+                    inclusionsHtml: string | null;
+                    exclusionsHtml: string | null;
+                    termsHtml: string | null;
+                    termsShowOnContract: boolean;
+                    bookingMode: "other" | "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary";
+                    capacityMode: "on_request" | "free_sale" | "limited";
+                    defaultLanguageTag: string | null;
+                    visibility: "public" | "private" | "hidden";
+                    activated: boolean;
+                    reservationTimeoutMinutes: number | null;
+                    sellCurrency: string;
+                    marginPercent: number | null;
+                    supplierId: string | null;
+                    pax: number | null;
+                    productTypeId: string | null;
+                    contractTemplateId: string | null;
+                    taxClassId: string | null;
+                    customerPaymentPolicy: import("hono/utils/types").JSONValue;
+                    tags: string[] | null;
+                };
+                options: {
+                    id: string;
+                    units: {
+                        id: string;
+                    }[];
+                }[];
+            };
+            outputFormat: "json";
+            status: 200 | 201;
+        };
+    };
+}, "/", "/:id/duplicate">;
 export declare const catalogAuthoringExtension: HonoExtension;
 export {};
 //# sourceMappingURL=extension.d.ts.map

package/dist/extension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,gBAAgB,CAAA;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAOjE;;;;;;;;;;;;;;GAcG;AAEH,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA;AAuCD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmBjC,CAAA;AAOF,eAAO,MAAM,yBAAyB,EAAE,aAGvC,CAAA"}
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,gBAAgB,CAAA;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAO1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAQjE;;;;;;;;;;;;;GAaG;AAEH,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA;AAmDD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA6D/B,CAAA;AAOJ,eAAO,MAAM,yBAAyB,EAAE,aAGvC,CAAA"}

package/dist/extension.js

@@ -1,37 +1,48 @@
 import { parseJsonBody } from "@voyantjs/hono";
-import { appendProductMutationLedgerEntry, emitProductContentChanged } from "@voyantjs/products";
+import { appendProductMutationLedgerEntry, emitProductContentChanged, } from "@voyantjs/products";
+import { productStatusEnum, productVisibilityEnum } from "@voyantjs/products/schema";
 import { Hono } from "hono";
 import { z } from "zod";
+import { cloneProduct } from "./clone.js";
 import { composeProduct } from "./service.js";
 import { productGraphSpecSchema } from "./spec.js";
 const composeBodySchema = z.object({
     spec: productGraphSpecSchema,
     idempotencyKey: z.string().min(1).max(255).optional(),
 });
+const duplicateBodySchema = z.object({
+    name: z.string().min(1).max(255).optional(),
+    status: z.enum(productStatusEnum.enumValues).optional(),
+    visibility: z.enum(productVisibilityEnum.enumValues).optional(),
+    copyDepartures: z.boolean().optional(),
+    idempotencyKey: z.string().min(1).max(255).optional(),
+});
 /** Header takes precedence over a body-supplied key. */
 function idempotencyKey(c, bodyKey) {
     return c.req.header("Idempotency-Key") ?? bodyKey;
 }
 /**
  * Records the same action-ledger entry + `product.content.changed` event the
- * granular product routes emit, so a composed product is indexed and audited
+ * granular product routes emit, so an authored product is indexed and audited
  * like any other create. Only called for freshly built products (a reused
  * idempotent response created nothing new).
  */
-async function recordComposed(
-// biome-ignore lint/suspicious/noExplicitAny: bridges this extension's Env to products' ledger Context<Env> (#1495); cast to LedgerContext below
-c, productId) {
+async function recordAuthoring(
+// biome-ignore lint/suspicious/noExplicitAny: bridges this extension's Env to products' ledger Context<Env> (#1493/#1495); cast to LedgerContext below
+c, action, productId) {
+    const verb = action === "duplicate" ? "duplicate" : "compose";
     await appendProductMutationLedgerEntry(c, {
-        action: "create",
+        action,
         productId,
         changedFields: [],
         subject: "product",
-        actionName: "product.compose",
-        routeOrToolName: "products.compose",
+        actionName: `product.${verb}`,
+        routeOrToolName: `products.${verb}`,
     });
     await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "product" });
 }
-export const catalogAuthoringRoutes = new Hono().post("/compose", async (c) => {
+export const catalogAuthoringRoutes = new Hono()
+    .post("/compose", async (c) => {
     const body = await parseJsonBody(c, composeBodySchema);
     const outcome = await composeProduct(c.get("db"), body.spec, {
         userId: c.get("userId"),
@@ -41,9 +52,45 @@ export const catalogAuthoringRoutes = new Hono().post("/compose", async (c) => {
         return c.json({ error: "invalid_product_graph", issues: outcome.issues }, 422);
     }
     if (!outcome.reused) {
-        await recordComposed(c, outcome.result.productId);
+        await recordAuthoring(c, "create", outcome.result.productId);
     }
     return c.json({ data: { id: outcome.result.productId, options: outcome.result.options } }, outcome.reused ? 200 : 201);
+})
+    .post("/:id/duplicate", async (c) => {
+    // The UI clones with no body; the agent sends overrides. Tolerate both.
+    const raw = (await c.req.text()).trim();
+    let body = {};
+    if (raw.length > 0) {
+        let json;
+        try {
+            json = JSON.parse(raw);
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const parsed = duplicateBodySchema.safeParse(json);
+        if (!parsed.success) {
+            return c.json({ error: "Invalid body", issues: parsed.error.issues }, 400);
+        }
+        body = parsed.data;
+    }
+    const outcome = await cloneProduct(c.get("db"), c.req.param("id"), {
+        name: body.name,
+        status: body.status,
+        visibility: body.visibility,
+        copyDepartures: body.copyDepartures,
+        userId: c.get("userId"),
+        idempotencyKey: idempotencyKey(c, body.idempotencyKey),
+    });
+    if (outcome.status === "not_found") {
+        return c.json({ error: "Product not found" }, 404);
+    }
+    if (!outcome.reused) {
+        await recordAuthoring(c, "duplicate", outcome.product.id);
+    }
+    // `data` stays the full product row (the UI reads `data.id`); `options`
+    // carries the cloned option/unit ids for agent follow-up calls.
+    return c.json({ data: outcome.product, options: outcome.options }, outcome.reused ? 200 : 201);
 });
 const catalogAuthoringExtensionDef = {
     name: "catalog-authoring",

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { Module } from "@voyantjs/core";
 export declare const catalogAuthoringModule: Module;
 export { type BuildProductGraphOptions, type BuildProductGraphResult, buildProductGraph, } from "./builder.js";
+export { type ClonedOption, type CloneProductOptions, type CloneProductOutcome, cloneProduct, } from "./clone.js";
 export { type AuthoringIssue, AuthoringValidationError } from "./errors.js";
 export { catalogAuthoringExtension, catalogAuthoringRoutes } from "./extension.js";
 export type { NewProductAuthoringRequest, ProductAuthoringRequest } from "./schema.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,eAAO,MAAM,sBAAsB,EAAE,MAEpC,CAAA;AAED,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,cAAc,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAC3E,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAClF,YAAY,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,cAAc,GACf,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,eAAO,MAAM,sBAAsB,EAAE,MAEpC,CAAA;AAED,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,cAAc,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAC3E,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAClF,YAAY,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,cAAc,GACf,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA"}

package/dist/index.js

@@ -2,6 +2,7 @@ export const catalogAuthoringModule = {
     name: "catalog-authoring",
 };
 export { buildProductGraph, } from "./builder.js";
+export { cloneProduct, } from "./clone.js";
 export { AuthoringValidationError } from "./errors.js";
 export { catalogAuthoringExtension, catalogAuthoringRoutes } from "./extension.js";
 export { productAuthoringRequests } from "./schema.js";

package/dist/service.d.ts

@@ -21,9 +21,8 @@ export type ComposeProductOutcome = {
  * caller can self-correct. Rules without a catalog fall back to the operator
  * default.
  *
- * Cloning an existing product is intentionally NOT handled here: the operator
- * template already ships a comprehensive deep-clone (`duplicateProductAsDraft`)
- * at `POST /v1/admin/products/{id}/duplicate`. See #1493.
+ * Cloning an existing product lives in `clone.ts` (`cloneProduct`); this module
+ * is the from-scratch path. See #1493 / #1495.
  */
 export declare function composeProduct(db: PostgresJsDatabase, spec: ProductGraphSpec, options?: AuthoringRunOptions): Promise<ComposeProductOutcome>;
 //# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,EAAE,KAAK,uBAAuB,EAAqB,MAAM,cAAc,CAAA;AAC9E,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,aAAa,CAAA;AAE3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAGjD,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,+EAA+E;IAC/E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,uBAAuB,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAClE;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,cAAc,EAAE,CAAA;CAAE,CAAA;AAgDnD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,gBAAgB,EACtB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,qBAAqB,CAAC,CAmBhC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,EAAE,KAAK,uBAAuB,EAAqB,MAAM,cAAc,CAAA;AAC9E,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,aAAa,CAAA;AAE3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAGjD,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,+EAA+E;IAC/E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,uBAAuB,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAClE;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,cAAc,EAAE,CAAA;CAAE,CAAA;AAgDnD;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,gBAAgB,EACtB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,qBAAqB,CAAC,CAmBhC"}

package/dist/service.js

@@ -44,9 +44,8 @@ async function withIdempotency(tx, key, operation, build) {
  * caller can self-correct. Rules without a catalog fall back to the operator
  * default.
  *
- * Cloning an existing product is intentionally NOT handled here: the operator
- * template already ships a comprehensive deep-clone (`duplicateProductAsDraft`)
- * at `POST /v1/admin/products/{id}/duplicate`. See #1493.
+ * Cloning an existing product lives in `clone.ts` (`cloneProduct`); this module
+ * is the from-scratch path. See #1493 / #1495.
  */
 export async function composeProduct(db, spec, options = {}) {
     const issues = validateProductGraph(spec);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/catalog-authoring",
-  "version": "0.105.0",
+  "version": "0.106.1",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -29,11 +29,13 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
+    "@voyantjs/availability": "^0.104.1",
     "@voyantjs/core": "^0.104.1",
     "@voyantjs/db": "^0.104.1",
+    "@voyantjs/extras": "^0.105.0",
     "@voyantjs/hono": "^0.104.1",
-    "@voyantjs/pricing": "^0.104.1",
-    "@voyantjs/products": "^0.104.3"
+    "@voyantjs/pricing": "^0.105.0",
+    "@voyantjs/products": "^0.105.0"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
@@ -56,7 +58,9 @@
     "requiresSchemas": [
       "@voyantjs/db",
       "@voyantjs/products",
-      "@voyantjs/pricing"
+      "@voyantjs/pricing",
+      "@voyantjs/availability",
+      "@voyantjs/extras"
     ]
   },
   "scripts": {