@zolve/offers 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,29 @@
-# Temporary Holding Version
+# @zolve/offers
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Motor de ofertas headless do Commerce OS (ADR-0083). O Commerce OS publica um **documento de ofertas**; a API e a ponte
+de cada loja rodam o mesmo código com ele, e a resposta é a mesma (avaliação remota ou local).
+
+- **Sem dependências de runtime**, ESM, sem `node:crypto` nem `TextEncoder`: cabe numa Shopify Function.
+- **Determinístico**: o pacote não lê relógio nem sorteia ao acaso. O instante entra pela chamada.
+- **Dinheiro em centavos inteiros** na moeda do documento.
+
+```ts
+import { decide, price, SUPPORTED_SCHEMA_VERSION } from '@zolve/offers';
+
+// Vitrine: que ofertas mostrar nesta posição, a que preço.
+const decision = decide(doc, { placement: 'cart', cart, visitorId, at: new Date().toISOString() });
+// decision.status: 'ok' | 'unsupported_schema'; decision.offers[i]: offerId, decisionId, kind, price, action, …
+
+// Cobrança: o preço de cada linha aceita (com offerId), conferindo as condições de novo com o carrinho real.
+const priced = price(doc, { cart, visitorId, at });
+// priced.lines[i]: { status: 'ok', unitPrice } | { status: 'ineligible', reason }
+```
+
+`decide` respeita condições, item disponível e fora do carrinho, vagas (e a vaga condicional), prioridade, um teste A/B
+por posição (sorteio do PostHog, em duas etapas) e o grupo de fora geral. `price` devolve a mesma variante de teste que
+o `decide` deu ao visitante.
+
+Documento com `schemaVersion` maior que `SUPPORTED_SCHEMA_VERSION` não é decidido nem precificado: a resposta vem com
+`status: 'unsupported_schema'` (e toda linha do `price` inelegível com esse motivo). Atualize o pacote.
+
+O schema Zod que valida o documento na publicação fica no Commerce OS (`@commerce-os/contracts`), fora deste pacote.

package/dist/cart.d.ts

@@ -0,0 +1,34 @@
+import type { CartLine } from './io.js';
+import type { Cents, ItemRef, OfferDocument, OfferItem, ProductMatch } from './types.js';
+export declare const itemKey: (ref: ItemRef) => string;
+/** Linha do carrinho com o que o documento sabe do item dela. */
+export interface ResolvedLine {
+    line: CartLine;
+    key: string;
+    storeProductId: string | null;
+    catalogProductIds: string[];
+    durationDays: number | null;
+}
+/**
+ * O carrinho do ponto de vista do motor. O gatilho é só o que a cliente escolheu: brinde e linha de oferta aceita ficam
+ * fora, senão a oferta aceita vira gatilho da próxima ("a fila que não acaba", app ADR 0006). `keys` é o carrinho
+ * inteiro: não se oferece o que ela já tem, venha de onde vier.
+ */
+export interface CartView {
+    chosen: ResolvedLine[];
+    accepted: ResolvedLine[];
+    keys: Set<string>;
+    /** Mercadoria sem brinde, linhas de oferta inclusive. */
+    subtotal: Cents;
+}
+export type ItemIndex = Map<string, OfferItem>;
+export declare function indexItems(doc: OfferDocument): ItemIndex;
+export declare function resolveLine(items: ItemIndex, line: CartLine): ResolvedLine;
+export declare function viewCart(items: ItemIndex, lines: CartLine[]): CartView;
+export declare function lineMatches(match: ProductMatch, line: ResolvedLine): boolean;
+export declare function anyLineMatches(match: ProductMatch, lines: ResolvedLine[]): boolean;
+/**
+ * Mesmo produto (ADR-0083 §3): mesmo produto da loja **ou** algum produto do catálogo em comum (a escada 30/90/180, o
+ * kit que contém o produto, o produto próprio de uma LP). Sem catálogo vale só a primeira parte.
+ */
+export declare function sameProduct(a: ResolvedLine, b: ResolvedLine): boolean;

package/dist/cart.js

@@ -0,0 +1,47 @@
+export const itemKey = (ref) => `${ref.source}:${ref.variantId}`;
+export function indexItems(doc) {
+    return new Map(doc.items.map((item) => [itemKey(item), item]));
+}
+export function resolveLine(items, line) {
+    const key = itemKey(line.item);
+    const item = items.get(key);
+    return {
+        line,
+        key,
+        storeProductId: item?.storeProductId ?? line.storeProductId ?? null,
+        catalogProductIds: item?.catalogProductIds ?? [],
+        durationDays: item?.durationDays ?? null,
+    };
+}
+function lineTotal(items, line) {
+    const unit = line.unitPrice ?? items.get(itemKey(line.item))?.price ?? 0;
+    return unit * line.quantity;
+}
+export function viewCart(items, lines) {
+    const resolved = lines.map((line) => resolveLine(items, line));
+    return {
+        chosen: resolved.filter(({ line }) => !line.gift && !line.offerId),
+        accepted: resolved.filter(({ line }) => !line.gift && line.offerId),
+        keys: new Set(resolved.map(({ key }) => key)),
+        subtotal: lines.filter((line) => !line.gift).reduce((sum, line) => sum + lineTotal(items, line), 0),
+    };
+}
+export function lineMatches(match, line) {
+    if (match.items?.some((ref) => itemKey(ref) === line.key))
+        return true;
+    if (line.storeProductId !== null && match.storeProductIds?.includes(line.storeProductId))
+        return true;
+    return line.catalogProductIds.some((id) => match.catalogProductIds?.includes(id) ?? false);
+}
+export function anyLineMatches(match, lines) {
+    return lines.some((line) => lineMatches(match, line));
+}
+/**
+ * Mesmo produto (ADR-0083 §3): mesmo produto da loja **ou** algum produto do catálogo em comum (a escada 30/90/180, o
+ * kit que contém o produto, o produto próprio de uma LP). Sem catálogo vale só a primeira parte.
+ */
+export function sameProduct(a, b) {
+    if (a.storeProductId !== null && a.storeProductId === b.storeProductId)
+        return true;
+    return a.catalogProductIds.some((id) => b.catalogProductIds.includes(id));
+}

package/dist/conditions.d.ts

@@ -0,0 +1,11 @@
+import { type CartView } from './cart.js';
+import type { IneligibleReason } from './io.js';
+import type { Offer, OfferCondition } from './types.js';
+/** `excluded` só existe no `decide`: o "produto que esconde" esconde a oferta, mas não desfaz a já aceita (app ADR 0025). */
+export type GateFailure = IneligibleReason | 'excluded';
+export declare function validityFailure(offer: Offer, at: string): 'not_started' | 'expired' | null;
+/**
+ * Toda oferta tem uma condição implícita: a cliente escolheu alguma coisa. A oferta "sempre" só aparece porque há
+ * carrinho; sozinha (ou só com brinde) ela é o promocional se sustentando em nada (app, `cart-bump-orphan.test.js`).
+ */
+export declare function conditionsFailure(conditions: OfferCondition[], view: CartView, mode: 'decide' | 'price'): GateFailure | null;

package/dist/conditions.js

@@ -0,0 +1,33 @@
+import { anyLineMatches } from './cart.js';
+export function validityFailure(offer, at) {
+    const now = Date.parse(at);
+    if (offer.validFrom !== undefined && now < Date.parse(offer.validFrom))
+        return 'not_started';
+    if (offer.validUntil !== undefined && now >= Date.parse(offer.validUntil))
+        return 'expired';
+    return null;
+}
+function conditionFailure(condition, view, mode) {
+    if (condition.type === 'cart_has_any')
+        return anyLineMatches(condition.match, view.chosen) ? null : 'trigger_missing';
+    if (condition.type === 'cart_has_none') {
+        return mode === 'price' || !anyLineMatches(condition.match, view.chosen) ? null : 'excluded';
+    }
+    const { min, max } = condition;
+    const inRange = (min === undefined || view.subtotal >= min) && (max === undefined || view.subtotal <= max);
+    return inRange ? null : 'subtotal_out_of_range';
+}
+/**
+ * Toda oferta tem uma condição implícita: a cliente escolheu alguma coisa. A oferta "sempre" só aparece porque há
+ * carrinho; sozinha (ou só com brinde) ela é o promocional se sustentando em nada (app, `cart-bump-orphan.test.js`).
+ */
+export function conditionsFailure(conditions, view, mode) {
+    if (view.chosen.length === 0)
+        return 'trigger_missing';
+    for (const condition of conditions) {
+        const failure = conditionFailure(condition, view, mode);
+        if (failure)
+            return failure;
+    }
+    return null;
+}

package/dist/decide.d.ts

@@ -0,0 +1,8 @@
+import type { Decision, DecideInput } from './io.js';
+import type { OfferDocument } from './types.js';
+/**
+ * As ofertas que valem para esta posição e este carrinho, com preço, tipo calculado e o teste sorteado. Respeita
+ * condições, item disponível e fora do carrinho, vagas (e a vaga condicional), prioridade, um teste por posição e o
+ * grupo de fora geral. Determinística: não lê relógio nem sorteia ao acaso.
+ */
+export declare function decide(doc: OfferDocument, input: DecideInput): Decision;

package/dist/decide.js

@@ -0,0 +1,131 @@
+import { anyLineMatches, indexItems, itemKey, resolveLine, viewCart } from './cart.js';
+import { conditionsFailure, validityFailure } from './conditions.js';
+import { placementOffers } from './effective.js';
+import { assignExperiment } from './experiments.js';
+import { classify } from './kind.js';
+import { compareAtPrice, offerUnitPrice, pricePerDay } from './money.js';
+import { isSupportedSchema } from './schema-version.js';
+import { sha1Hex } from './sha1.js';
+/** Vagas deste carrinho: as da posição, mais a extra quando o carrinho escolhido casa (a 2ª vaga presa a produtos). */
+function slotsFor(placement, view) {
+    const extra = placement.extraSlot && anyLineMatches(placement.extraSlot.when, view.chosen) ? 1 : 0;
+    return placement.slots + extra;
+}
+/** A posição de onde veio uma linha aceita: a que ela declara, ou a da oferta com aquele id. */
+function acceptedPlacement(doc, line) {
+    return line.placement ?? doc.offers.find((offer) => offer.id === line.offerId)?.placement;
+}
+/**
+ * Vagas abertas: as do carrinho menos as ofertas já aceitas nesta posição (app ADR 0017). Aceitar uma e ver outra
+ * nascer no lugar é a fila que não acaba; com duas vagas e uma aceita, fica a que já estava ao lado.
+ */
+function openSlots(ctx) {
+    const accepted = ctx.view.accepted.filter(({ line }) => acceptedPlacement(ctx.doc, line) === ctx.placement.key).length;
+    return Math.max(0, slotsFor(ctx.placement, ctx.view) - accepted);
+}
+function candidate(ctx, offer) {
+    if (!offer.active || validityFailure(offer, ctx.at))
+        return null;
+    const item = ctx.items.get(itemKey(offer.item));
+    if (!item?.available || ctx.view.keys.has(itemKey(offer.item)))
+        return null;
+    if (conditionsFailure(offer.conditions, ctx.view, 'decide'))
+        return null;
+    const classification = classify(resolveLine(ctx.items, { item: offer.item, quantity: 1 }), ctx.view.chosen);
+    if (offer.action === 'replace' && !classification.target)
+        return null;
+    return { offer, item, classification };
+}
+/** A fila da posição: quem passa nas condições, sem repetir item, na ordem de prioridade, até fechar as vagas. */
+function pickOffers(ctx) {
+    const picks = [];
+    const seen = new Set();
+    const open = openSlots(ctx);
+    for (const offer of placementOffers(ctx.doc, ctx.placement.key, ctx.variant)) {
+        if (picks.length >= open)
+            break;
+        const pick = candidate(ctx, offer);
+        if (!pick || seen.has(itemKey(pick.offer.item)))
+            continue;
+        seen.add(itemKey(pick.offer.item));
+        picks.push(pick);
+    }
+    return picks;
+}
+function groupingFor(ctx) {
+    if (slotsFor(ctx.placement, ctx.view) < 2)
+        return null;
+    const groupings = ctx.variant?.groupings ?? ctx.placement.groupings ?? [];
+    return groupings.find((grouping) => anyLineMatches(grouping.when, ctx.view.chosen))?.presentation ?? null;
+}
+/**
+ * Mesmo documento, carrinho, visitante e resposta = mesmo id (ADR-0083 §1, princípio 3). O instante não entra: duas
+ * perguntas iguais seguidas são a mesma decisão. A ordem das linhas também não.
+ */
+function decisionIdOf(input, version, offerIds, experiments) {
+    const cart = input.cart
+        .map((line) => [itemKey(line.item), line.quantity, line.offerId ?? '', line.gift ? 1 : 0].join('*'))
+        .sort();
+    const canonical = JSON.stringify([version, input.placement, input.visitorId ?? '', cart, offerIds, experiments]);
+    return `dec_${sha1Hex(canonical).slice(0, 24)}`;
+}
+function toDecided(ctx, pick, slot, decisionId) {
+    const { offer, item, classification } = pick;
+    const price = offerUnitPrice(offer.price, item.price);
+    return {
+        offerId: offer.id,
+        decisionId,
+        placement: ctx.placement.key,
+        slot,
+        kind: classification.kind,
+        direction: classification.direction,
+        item: { source: item.source, variantId: item.variantId },
+        price,
+        compareAtPrice: compareAtPrice(item.price, price),
+        pricePerDay: pricePerDay(price, item.durationDays),
+        currency: ctx.doc.currency,
+        action: offer.action,
+        replaces: offer.action === 'replace' ? (classification.target?.line.item ?? null) : null,
+        content: offer.content,
+        presentation: offer.presentation ?? placementPresentation(ctx),
+    };
+}
+function placementPresentation(ctx) {
+    return ctx.variant?.presentation ?? ctx.placement.presentation ?? null;
+}
+/**
+ * Posição desconhecida responde vazio (a ponte ainda manda o `exposed`), nunca erro. Documento de formato mais novo
+ * também responde vazio, com `status: 'unsupported_schema'`, para a ponte saber que precisa atualizar o pacote.
+ */
+function emptyDecision(doc, input, status) {
+    const decisionId = decisionIdOf(input, doc.version, [], []);
+    return { status, version: doc.version, placement: input.placement, decisionId, offers: [], presentation: null, grouping: null, experiments: [] };
+}
+/**
+ * As ofertas que valem para esta posição e este carrinho, com preço, tipo calculado e o teste sorteado. Respeita
+ * condições, item disponível e fora do carrinho, vagas (e a vaga condicional), prioridade, um teste por posição e o
+ * grupo de fora geral. Determinística: não lê relógio nem sorteia ao acaso.
+ */
+export function decide(doc, input) {
+    if (!isSupportedSchema(doc.schemaVersion))
+        return emptyDecision(doc, input, 'unsupported_schema');
+    const placement = doc.placements.find((candidatePlacement) => candidatePlacement.key === input.placement);
+    if (!placement)
+        return emptyDecision(doc, input, 'ok');
+    const assignment = assignExperiment(doc, placement.key, input.visitorId);
+    const items = indexItems(doc);
+    const ctx = { doc, items, view: viewCart(items, input.cart), placement, variant: assignment?.variant ?? null, at: input.at };
+    const picks = pickOffers(ctx);
+    const experiments = assignment ? [{ key: assignment.experiment.key, variant: assignment.variant.key }] : [];
+    const decisionId = decisionIdOf(input, doc.version, picks.map((pick) => pick.offer.id), experiments);
+    return {
+        status: 'ok',
+        version: doc.version,
+        placement: placement.key,
+        decisionId,
+        offers: picks.map((pick, index) => toDecided(ctx, pick, index + 1, decisionId)),
+        presentation: placementPresentation(ctx),
+        grouping: groupingFor(ctx),
+        experiments,
+    };
+}

package/dist/effective.d.ts

@@ -0,0 +1,5 @@
+import type { ExperimentVariant, Offer, OfferDocument } from './types.js';
+/** A oferta como esta variante a mostra: campo ausente na mudança fica como no documento; o conteúdo mescla. */
+export declare function applyVariant(offer: Offer, variant: ExperimentVariant | null): Offer;
+/** As ofertas da posição, com a variante aplicada, na ordem de prioridade (empate: ordem do documento). */
+export declare function placementOffers(doc: OfferDocument, placement: string, variant: ExperimentVariant | null): Offer[];

package/dist/effective.js

@@ -0,0 +1,21 @@
+/** A oferta como esta variante a mostra: campo ausente na mudança fica como no documento; o conteúdo mescla. */
+export function applyVariant(offer, variant) {
+    const change = variant?.offers.find((override) => override.offerId === offer.id);
+    if (!change)
+        return offer;
+    return {
+        ...offer,
+        active: change.active ?? offer.active,
+        price: change.price ?? offer.price,
+        content: { ...offer.content, ...change.content },
+        presentation: change.presentation ?? offer.presentation,
+    };
+}
+/** As ofertas da posição, com a variante aplicada, na ordem de prioridade (empate: ordem do documento). */
+export function placementOffers(doc, placement, variant) {
+    return doc.offers
+        .map((offer, order) => ({ offer, order }))
+        .filter(({ offer }) => offer.placement === placement)
+        .sort((a, b) => a.offer.priority - b.offer.priority || a.order - b.order)
+        .map(({ offer }) => applyVariant(offer, variant));
+}

package/dist/experiments.d.ts

@@ -0,0 +1,24 @@
+import type { Experiment, ExperimentVariant, Holdout, OfferDocument } from './types.js';
+/**
+ * O hash do PostHog (`calculate_hash` do `feature-flags` em Rust, `_hash` do Python): `sha1(prefixo + id + sal)`, os 60
+ * primeiros bits divididos pela escala, num número entre 0 e 1. Os 60 bits saem das duas primeiras palavras sem BigInt
+ * (`hi · 2²⁸ + lo >>> 4`), arredondados uma vez só, como o `u64 as f64` deles.
+ */
+export declare function hashBucket(prefix: string, identifier: string, salt: string): number;
+/** Entra quem tem hash ≤ porcentagem (PostHog `is_in_rollout`). */
+export declare function inRollout(percentage: number, hash: number): boolean;
+/** A variante pela soma acumulada das porcentagens, na ordem cadastrada (PostHog `select_variant`). */
+export declare function selectVariant(hash: number, variants: ExperimentVariant[]): ExperimentVariant | null;
+/** Grupo de fora geral: prefixo `holdout-` do PostHog, sem chave de teste (vale para todos). */
+export declare function inHoldout(holdout: Holdout, visitorId: string): boolean;
+export interface Assignment {
+    experiment: Experiment;
+    variant: ExperimentVariant;
+}
+/**
+ * Sorteio em duas etapas (ADR-0047, emenda de testes A/B): primeiro se o visitante entra no teste, depois em qual
+ * variante, as duas com `sha1("<teste>.<visitante><sal>")` e sais diferentes (o do teste, e o do teste + `variant`,
+ * como o PostHog) para as decisões não ficarem ligadas. Um teste por posição: vale o primeiro ativo. Visitante sem id
+ * nunca entra; quem está no grupo de fora geral também não.
+ */
+export declare function assignExperiment(doc: OfferDocument, placement: string, visitorId: string | undefined): Assignment | null;

package/dist/experiments.js

@@ -0,0 +1,51 @@
+import { sha1Words } from './sha1.js';
+/**
+ * 15 dígitos hexa (60 bits), como o PostHog: `int(sha1[:15], 16) / 0xfffffffffffffff`. Em double, 2⁶⁰ − 1 arredonda
+ * para 2⁶⁰ — que é o `LONG_SCALE as f64` do Rust deles; escrito assim para não fingir um inteiro que o double não guarda.
+ */
+const LONG_SCALE = 2 ** 60;
+/**
+ * O hash do PostHog (`calculate_hash` do `feature-flags` em Rust, `_hash` do Python): `sha1(prefixo + id + sal)`, os 60
+ * primeiros bits divididos pela escala, num número entre 0 e 1. Os 60 bits saem das duas primeiras palavras sem BigInt
+ * (`hi · 2²⁸ + lo >>> 4`), arredondados uma vez só, como o `u64 as f64` deles.
+ */
+export function hashBucket(prefix, identifier, salt) {
+    const [hi = 0, lo = 0] = sha1Words(`${prefix}${identifier}${salt}`);
+    return (hi * 2 ** 28 + (lo >>> 4)) / LONG_SCALE;
+}
+/** Entra quem tem hash ≤ porcentagem (PostHog `is_in_rollout`). */
+export function inRollout(percentage, hash) {
+    return percentage >= 100 || hash <= percentage / 100;
+}
+/** A variante pela soma acumulada das porcentagens, na ordem cadastrada (PostHog `select_variant`). */
+export function selectVariant(hash, variants) {
+    let cumulative = 0;
+    for (const variant of variants) {
+        cumulative += variant.percentage / 100;
+        if (hash < cumulative)
+            return variant;
+    }
+    return null;
+}
+/** Grupo de fora geral: prefixo `holdout-` do PostHog, sem chave de teste (vale para todos). */
+export function inHoldout(holdout, visitorId) {
+    return holdout.enabled && inRollout(holdout.percentage, hashBucket('holdout-', visitorId, holdout.salt ?? ''));
+}
+/**
+ * Sorteio em duas etapas (ADR-0047, emenda de testes A/B): primeiro se o visitante entra no teste, depois em qual
+ * variante, as duas com `sha1("<teste>.<visitante><sal>")` e sais diferentes (o do teste, e o do teste + `variant`,
+ * como o PostHog) para as decisões não ficarem ligadas. Um teste por posição: vale o primeiro ativo. Visitante sem id
+ * nunca entra; quem está no grupo de fora geral também não.
+ */
+export function assignExperiment(doc, placement, visitorId) {
+    if (!visitorId)
+        return null;
+    const experiment = doc.experiments.find((candidate) => candidate.active && candidate.placement === placement);
+    if (!experiment || inHoldout(doc.holdout, visitorId))
+        return null;
+    const salt = experiment.salt ?? '';
+    if (!inRollout(experiment.percentage, hashBucket(`${experiment.key}.`, visitorId, salt)))
+        return null;
+    const variant = selectVariant(hashBucket(`${experiment.key}.`, visitorId, `${salt}variant`), experiment.variants);
+    return variant ? { experiment, variant } : null;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type * from './types.js';
+export type * from './io.js';
+export { decide } from './decide.js';
+export { price } from './price.js';
+export { hashBucket, inRollout, selectVariant } from './experiments.js';
+export { compareAtPrice, offerUnitPrice, pricePerDay } from './money.js';
+export { SUPPORTED_SCHEMA_VERSION } from './schema-version.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { decide } from './decide.js';
+export { price } from './price.js';
+export { hashBucket, inRollout, selectVariant } from './experiments.js';
+export { compareAtPrice, offerUnitPrice, pricePerDay } from './money.js';
+export { SUPPORTED_SCHEMA_VERSION } from './schema-version.js';

package/dist/io.d.ts

@@ -0,0 +1,97 @@
+import type { Cents, ItemRef, OfferAction, OfferContent } from './types.js';
+/** Uma linha do carrinho como a ponte a vê. */
+export interface CartLine {
+    item: ItemRef;
+    quantity: number;
+    /** O que a loja cobra por unidade agora; sem ele vale o preço do item no documento (0 se ele não estiver lá). */
+    unitPrice?: Cents;
+    /** Produto da loja da linha, para o item que o documento não lista (o produto que a cliente escolheu). */
+    storeProductId?: string;
+    /** Linha de oferta aceita: leva o `offerId` até o pedido (ADR-0083 §1, princípio 4). Não é gatilho de outra oferta. */
+    offerId?: string;
+    /** A posição de onde a oferta aceita veio; desempata o id repetido em duas posições. */
+    placement?: string;
+    /** Na ação `replace`: o item que a oferta trocou. `price()` confere a condição como se ele ainda estivesse lá. */
+    replacedItem?: ItemRef;
+    /** Brinde: não é escolha da cliente nem entra no subtotal. */
+    gift?: boolean;
+}
+export interface DecideInput {
+    placement: string;
+    cart: CartLine[];
+    /** Sem visitante não há sorteio: ele nunca entra em teste. */
+    visitorId?: string;
+    /** Instante ISO com offset. O pacote nunca lê o relógio: a decisão é determinística. */
+    at: string;
+}
+export interface ExperimentAssignment {
+    key: string;
+    variant: string;
+}
+/** Calculado, nunca cadastrado (ADR-0083 §3): mesmo produto é upsell, outro é cross-sell. */
+export type DecidedOfferKind = 'upsell' | 'cross_sell';
+export interface DecidedOffer {
+    offerId: string;
+    decisionId: string;
+    placement: string;
+    /** Posição na vaga, a partir de 1 (o `slot` do evento `viewed`). */
+    slot: number;
+    kind: DecidedOfferKind;
+    /** Só no upsell com duração no catálogo: 30 → 90 sobe, 90 → 30 desce. */
+    direction: 'up' | 'down' | null;
+    item: ItemRef;
+    price: Cents;
+    /** O preço da loja, quando maior que o da oferta. */
+    compareAtPrice: Cents | null;
+    /** Com duração no catálogo. */
+    pricePerDay: Cents | null;
+    currency: string;
+    action: OfferAction;
+    /** O item que a cliente leva e a oferta troca, na ação `replace`. */
+    replaces: ItemRef | null;
+    content: OfferContent;
+    presentation: string | null;
+}
+/** `unsupported_schema`: documento num formato mais novo que o pacote; nada é decidido (sem ofertas, sem teste). */
+export type ResultStatus = 'ok' | 'unsupported_schema';
+export interface Decision {
+    status: ResultStatus;
+    version: number;
+    placement: string;
+    /** Mesmo documento, carrinho, visitante e resposta = mesmo id. Sai também sem oferta (para o `exposed`). */
+    decisionId: string;
+    offers: DecidedOffer[];
+    /** Apresentação padrão da posição (já com a variante do teste). */
+    presentation: string | null;
+    /** Apresentação de grupo (combo) quando vale para este carrinho. */
+    grouping: string | null;
+    experiments: ExperimentAssignment[];
+}
+export interface PriceInput {
+    cart: CartLine[];
+    /** O mesmo do `decide`: a variante do teste é sorteada de novo por ele. */
+    visitorId?: string;
+    at: string;
+}
+export type IneligibleReason = 'unknown_offer' | 'inactive' | 'item_mismatch' | 'not_started' | 'expired' | 'trigger_missing' | 'subtotal_out_of_range'
+/** O documento é de um formato mais novo que o pacote: toda linha volta com este motivo. */
+ | 'unsupported_schema';
+export type PricedLine = {
+    index: number;
+    offerId: string;
+    status: 'ok';
+    unitPrice: Cents;
+    compareAtPrice: Cents | null;
+} | {
+    index: number;
+    offerId: string;
+    status: 'ineligible';
+    reason: IneligibleReason;
+};
+export interface PriceResult {
+    status: ResultStatus;
+    version: number;
+    currency: string;
+    /** Uma por linha com `offerId`, na ordem do carrinho; `index` é a posição da linha no carrinho de entrada. */
+    lines: PricedLine[];
+}

package/dist/io.js

@@ -0,0 +1 @@
+export {};

package/dist/kind.d.ts

@@ -0,0 +1,13 @@
+import { type ResolvedLine } from './cart.js';
+import type { DecidedOfferKind } from './io.js';
+export interface Classification {
+    kind: DecidedOfferKind;
+    direction: 'up' | 'down' | null;
+    /** A linha escolhida do mesmo produto: a que a ação `replace` troca. */
+    target: ResolvedLine | null;
+}
+/**
+ * Tipo calculado, nunca cadastrado (ADR-0083 §3; a mesma regra do `offerKindExpr` da análise): upsell quando o carrinho
+ * escolhido já tem o mesmo produto, cross-sell quando é outro. A direção sai da duração no catálogo.
+ */
+export declare function classify(offered: ResolvedLine, chosen: ResolvedLine[]): Classification;

package/dist/kind.js

@@ -0,0 +1,18 @@
+import { sameProduct } from './cart.js';
+function directionOf(offered, target) {
+    if (offered.durationDays === null || target.durationDays === null)
+        return null;
+    if (offered.durationDays === target.durationDays)
+        return null;
+    return offered.durationDays > target.durationDays ? 'up' : 'down';
+}
+/**
+ * Tipo calculado, nunca cadastrado (ADR-0083 §3; a mesma regra do `offerKindExpr` da análise): upsell quando o carrinho
+ * escolhido já tem o mesmo produto, cross-sell quando é outro. A direção sai da duração no catálogo.
+ */
+export function classify(offered, chosen) {
+    const target = chosen.find((line) => sameProduct(offered, line)) ?? null;
+    if (!target)
+        return { kind: 'cross_sell', direction: null, target: null };
+    return { kind: 'upsell', direction: directionOf(offered, target), target };
+}

package/dist/money.d.ts

@@ -0,0 +1,11 @@
+import type { Cents, OfferPrice } from './types.js';
+/**
+ * Preço da oferta por unidade, a partir do preço da loja. O desconto percentual é arredondado meio para cima (15% de
+ * 79,90 = 11,985 → 11,99, cobra 67,91). A oferta é **teto**, nunca acréscimo: o resultado fica entre 0 e o preço da
+ * loja (preço fixo acima da loja cobra o da loja, desconto maior que o preço vira grátis).
+ */
+export declare function offerUnitPrice(price: OfferPrice, storePrice: Cents): Cents;
+/** O preço "de": o da loja, só quando há o que riscar. */
+export declare function compareAtPrice(storePrice: Cents, price: Cents): Cents | null;
+/** Preço por dia pela duração da variante no catálogo, arredondado meio para cima. */
+export declare function pricePerDay(price: Cents, durationDays: number | undefined): Cents | null;

package/dist/money.js

@@ -0,0 +1,27 @@
+/** Divisão inteira arredondada meio para cima (a regra de centavo de sempre: 0,5 sobe). Só para valores ≥ 0. */
+function divideHalfUp(numerator, denominator) {
+    return Math.floor((2 * numerator + denominator) / (2 * denominator));
+}
+/**
+ * Preço da oferta por unidade, a partir do preço da loja. O desconto percentual é arredondado meio para cima (15% de
+ * 79,90 = 11,985 → 11,99, cobra 67,91). A oferta é **teto**, nunca acréscimo: o resultado fica entre 0 e o preço da
+ * loja (preço fixo acima da loja cobra o da loja, desconto maior que o preço vira grátis).
+ */
+export function offerUnitPrice(price, storePrice) {
+    const raw = price.type === 'fixed'
+        ? price.amount
+        : price.type === 'amount_off'
+            ? storePrice - price.amount
+            : storePrice - divideHalfUp(storePrice * price.basisPoints, 10_000);
+    return Math.min(storePrice, Math.max(0, raw));
+}
+/** O preço "de": o da loja, só quando há o que riscar. */
+export function compareAtPrice(storePrice, price) {
+    return storePrice > price ? storePrice : null;
+}
+/** Preço por dia pela duração da variante no catálogo, arredondado meio para cima. */
+export function pricePerDay(price, durationDays) {
+    if (!durationDays || durationDays <= 0)
+        return null;
+    return divideHalfUp(price, durationDays);
+}

package/dist/price.d.ts

@@ -0,0 +1,10 @@
+import type { PriceInput, PriceResult } from './io.js';
+import type { OfferDocument } from './types.js';
+/**
+ * O preço de cada linha de oferta aceita, **conferindo as condições de novo** com o carrinho real (ADR-0083 §1,
+ * princípio 2, e §6). Linha que perdeu a condição volta `ineligible` com o motivo, e a ponte escolhe remover ou cobrar
+ * o preço cheio. Documento de formato mais novo que o pacote não é precificado: toda linha volta `unsupported_schema`.
+ * A variante do teste é sorteada de novo pelo visitante, a mesma que o `decide` deu. O "produto que
+ * esconde" (`cart_has_none`) não é conferido aqui: esconder não desfaz a oferta já aceita (app ADR 0025).
+ */
+export declare function price(doc: OfferDocument, input: PriceInput): PriceResult;

package/dist/price.js

@@ -0,0 +1,77 @@
+import { indexItems, itemKey, resolveLine, sameProduct, viewCart } from './cart.js';
+import { conditionsFailure, validityFailure } from './conditions.js';
+import { applyVariant } from './effective.js';
+import { assignExperiment } from './experiments.js';
+import { compareAtPrice, offerUnitPrice } from './money.js';
+import { isSupportedSchema } from './schema-version.js';
+/** O id repetido em duas posições (oferta migrada do app) desempata pela posição da linha; sem ela, vale a primeira. */
+function findOffer(doc, line) {
+    const same = doc.offers.filter((offer) => offer.id === line.offerId);
+    return same.find((offer) => offer.placement === line.placement) ?? same[0];
+}
+/**
+ * O carrinho como no instante em que a oferta apareceu: sem a própria linha (senão uma oferta por valor mínimo se
+ * sustenta sozinha, o preço dela empurra o subtotal que ela exige) e, no `replace`, com o item trocado de volta no
+ * lugar. Nulo quando o `replace` não diz o que trocou, ou diz um item que não é o mesmo produto.
+ */
+function recheckView(ctx, offer, index) {
+    const line = ctx.input.cart[index];
+    const others = ctx.input.cart.filter((_, position) => position !== index);
+    if (offer.action === 'add')
+        return viewCart(ctx.items, others);
+    if (!line.replacedItem)
+        return null;
+    const replaced = { item: line.replacedItem, quantity: line.quantity };
+    if (!sameProduct(resolveLine(ctx.items, replaced), resolveLine(ctx.items, line)))
+        return null;
+    return viewCart(ctx.items, [...others, replaced]);
+}
+function lineFailure(ctx, offer, index) {
+    const line = ctx.input.cart[index];
+    if (!offer.active)
+        return 'inactive';
+    if (!ctx.items.has(itemKey(offer.item)))
+        return 'unknown_offer';
+    if (itemKey(line.item) !== itemKey(offer.item))
+        return 'item_mismatch';
+    const validity = validityFailure(offer, ctx.input.at);
+    if (validity)
+        return validity;
+    const view = recheckView(ctx, offer, index);
+    if (!view)
+        return 'trigger_missing';
+    const failure = conditionsFailure(offer.conditions, view, 'price');
+    return failure === 'excluded' ? null : failure;
+}
+function priceLine(ctx, line, index) {
+    const offerId = line.offerId;
+    const found = findOffer(ctx.doc, line);
+    if (!found)
+        return { index, offerId, status: 'ineligible', reason: 'unknown_offer' };
+    const assignment = assignExperiment(ctx.doc, found.placement, ctx.input.visitorId);
+    const offer = applyVariant(found, assignment?.variant ?? null);
+    const reason = lineFailure(ctx, offer, index);
+    if (reason)
+        return { index, offerId, status: 'ineligible', reason };
+    const storePrice = ctx.items.get(itemKey(offer.item)).price;
+    const charged = line.unitPrice ?? storePrice;
+    const unitPrice = Math.min(offerUnitPrice(offer.price, storePrice), charged);
+    return { index, offerId, status: 'ok', unitPrice, compareAtPrice: compareAtPrice(charged, unitPrice) };
+}
+/**
+ * O preço de cada linha de oferta aceita, **conferindo as condições de novo** com o carrinho real (ADR-0083 §1,
+ * princípio 2, e §6). Linha que perdeu a condição volta `ineligible` com o motivo, e a ponte escolhe remover ou cobrar
+ * o preço cheio. Documento de formato mais novo que o pacote não é precificado: toda linha volta `unsupported_schema`.
+ * A variante do teste é sorteada de novo pelo visitante, a mesma que o `decide` deu. O "produto que
+ * esconde" (`cart_has_none`) não é conferido aqui: esconder não desfaz a oferta já aceita (app ADR 0025).
+ */
+export function price(doc, input) {
+    const head = { version: doc.version, currency: doc.currency };
+    if (!isSupportedSchema(doc.schemaVersion)) {
+        const lines = input.cart.flatMap((line, index) => line.offerId ? [{ index, offerId: line.offerId, status: 'ineligible', reason: 'unsupported_schema' }] : []);
+        return { status: 'unsupported_schema', ...head, lines };
+    }
+    const ctx = { doc, items: indexItems(doc), input };
+    const lines = input.cart.flatMap((line, index) => (line.offerId ? [priceLine(ctx, line, index)] : []));
+    return { status: 'ok', ...head, lines };
+}

package/dist/schema-version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Versão do formato do documento que este pacote entende. Sobe quando o formato muda de um jeito que um pacote antigo
+ * leria errado (campo novo que muda a decisão ou o preço). Documento com `schemaVersion` maior não é decidido nem
+ * precificado: a resposta diz `unsupported_schema` e a ponte sabe que precisa atualizar o pacote, em vez de cobrar
+ * com uma regra que não conhece.
+ */
+export declare const SUPPORTED_SCHEMA_VERSION = 1;
+export declare function isSupportedSchema(schemaVersion: number): boolean;

package/dist/schema-version.js

@@ -0,0 +1,10 @@
+/**
+ * Versão do formato do documento que este pacote entende. Sobe quando o formato muda de um jeito que um pacote antigo
+ * leria errado (campo novo que muda a decisão ou o preço). Documento com `schemaVersion` maior não é decidido nem
+ * precificado: a resposta diz `unsupported_schema` e a ponte sabe que precisa atualizar o pacote, em vez de cobrar
+ * com uma regra que não conhece.
+ */
+export const SUPPORTED_SCHEMA_VERSION = 1;
+export function isSupportedSchema(schemaVersion) {
+    return Number.isInteger(schemaVersion) && schemaVersion >= 1 && schemaVersion <= SUPPORTED_SCHEMA_VERSION;
+}

package/dist/sha1.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SHA-1 em TypeScript puro. A Shopify Function (Javy/QuickJS) não tem `node:crypto` nem Web Crypto síncrono, e o
+ * sorteio A/B precisa do mesmo hash do PostHog (ADR-0047, emenda de testes A/B). Não é uso criptográfico: é só a
+ * função de espalhamento que deixa o sorteio igual ao do PostHog.
+ */
+/** Texto → bytes UTF-8, sem `TextEncoder` (nem todo runtime da ponte tem). */
+export declare function utf8Bytes(text: string): number[];
+/** Os 20 bytes do SHA-1 como cinco palavras de 32 bits sem sinal. */
+export declare function sha1Words(text: string): number[];
+export declare function sha1Hex(text: string): string;

package/dist/sha1.js

@@ -0,0 +1,76 @@
+/**
+ * SHA-1 em TypeScript puro. A Shopify Function (Javy/QuickJS) não tem `node:crypto` nem Web Crypto síncrono, e o
+ * sorteio A/B precisa do mesmo hash do PostHog (ADR-0047, emenda de testes A/B). Não é uso criptográfico: é só a
+ * função de espalhamento que deixa o sorteio igual ao do PostHog.
+ */
+/** Texto → bytes UTF-8, sem `TextEncoder` (nem todo runtime da ponte tem). */
+export function utf8Bytes(text) {
+    const bytes = [];
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code < 0x80)
+            bytes.push(code);
+        else if (code < 0x800)
+            bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+        else if (code < 0x10000)
+            bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        else
+            bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    }
+    return bytes;
+}
+/** Mensagem com o enchimento do SHA-1: 0x80, zeros e o tamanho em bits (64 bits, big-endian). */
+function padded(bytes) {
+    const bitLength = bytes.length * 8;
+    const out = [...bytes, 0x80];
+    while (out.length % 64 !== 56)
+        out.push(0);
+    const high = Math.floor(bitLength / 0x100000000);
+    for (const word of [high, bitLength >>> 0])
+        out.push((word >>> 24) & 0xff, (word >>> 16) & 0xff, (word >>> 8) & 0xff, word & 0xff);
+    return out;
+}
+const rotl = (value, bits) => (value << bits) | (value >>> (32 - bits));
+function roundMix(t, b, c, d) {
+    if (t < 20)
+        return ((b & c) | (~b & d)) + 0x5a827999;
+    if (t < 40)
+        return (b ^ c ^ d) + 0x6ed9eba1;
+    if (t < 60)
+        return ((b & c) | (b & d) | (c & d)) + 0x8f1bbcdc;
+    return (b ^ c ^ d) + 0xca62c1d6;
+}
+function compress(state, block, offset) {
+    const w = [];
+    for (let t = 0; t < 16; t++) {
+        const i = offset + t * 4;
+        w[t] = ((block[i] ?? 0) << 24) | ((block[i + 1] ?? 0) << 16) | ((block[i + 2] ?? 0) << 8) | (block[i + 3] ?? 0);
+    }
+    for (let t = 16; t < 80; t++)
+        w[t] = rotl((w[t - 3] ?? 0) ^ (w[t - 8] ?? 0) ^ (w[t - 14] ?? 0) ^ (w[t - 16] ?? 0), 1);
+    let [a, b, c, d, e] = state;
+    for (let t = 0; t < 80; t++) {
+        const temp = (rotl(a, 5) + roundMix(t, b, c, d) + e + (w[t] ?? 0)) | 0;
+        e = d;
+        d = c;
+        c = rotl(b, 30);
+        b = a;
+        a = temp;
+    }
+    [a, b, c, d, e].forEach((value, i) => {
+        state[i] = ((state[i] ?? 0) + value) | 0;
+    });
+}
+/** Os 20 bytes do SHA-1 como cinco palavras de 32 bits sem sinal. */
+export function sha1Words(text) {
+    const message = padded(utf8Bytes(text));
+    const state = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+    for (let offset = 0; offset < message.length; offset += 64)
+        compress(state, message, offset);
+    return state.map((word) => word >>> 0);
+}
+export function sha1Hex(text) {
+    return sha1Words(text)
+        .map((word) => word.toString(16).padStart(8, '0'))
+        .join('');
+}

package/dist/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Tipos do motor de ofertas (ADR-0083). O documento publicado é a única entrada de `decide()` e `price()`: a API do
+ * Commerce OS e a ponte de cada loja (avaliação local, Shopify Function) rodam o mesmo código com o mesmo documento.
+ *
+ * Dinheiro: **centavos inteiros** (unidade menor da moeda do documento) em todo lugar do pacote. Nada de float: a
+ * Function cobra o que o pacote calcula, e 79,90 em float vira 79,899999. O arredondamento é explícito em `money.ts`.
+ */
+/** Valor em centavos (inteiro ≥ 0), na moeda do documento. */
+export type Cents = number;
+/** Item: uma variante vendável da loja, por origem + id da variante (`shopify` + `5167…`), como em `store_item`. */
+export interface ItemRef {
+    source: string;
+    variantId: string;
+}
+/** Item referenciado pelo documento, com o que o motor precisa saber dele na hora de decidir. */
+export interface OfferItem extends ItemRef {
+    /** Preço da loja: base do preço da oferta e o preço "de". */
+    price: Cents;
+    available: boolean;
+    /** Produto da loja: "mesmo produto" pela primeira regra (ADR-0083 §3). */
+    storeProductId: string;
+    /** Produtos do catálogo curado (ADR-0036): um para a variante, os que ele contém para o kit. */
+    catalogProductIds?: string[];
+    /** Duração da variante no catálogo (30, 90, 180): dá a direção do upsell e o preço por dia. */
+    durationDays?: number;
+}
+/** Conjunto de itens, produtos da loja ou produtos do catálogo. Casa se qualquer um casar. */
+export interface ProductMatch {
+    items?: ItemRef[];
+    storeProductIds?: string[];
+    catalogProductIds?: string[];
+}
+/** Condições: lista fixa e tipada, sem linguagem de regras (ADR-0003). Todas precisam valer. */
+export type OfferCondition = 
+/** O carrinho que a cliente escolheu tem algum destes. */
+{
+    type: 'cart_has_any';
+    match: ProductMatch;
+}
+/** O carrinho que a cliente escolheu não tem nenhum destes ("produtos que escondem"). Só esconde: não desfaz aceita. */
+ | {
+    type: 'cart_has_none';
+    match: ProductMatch;
+}
+/** Subtotal da mercadoria (sem brinde) dentro da faixa, limites inclusivos. */
+ | {
+    type: 'subtotal_between';
+    min?: Cents;
+    max?: Cents;
+};
+/** Preço da oferta, sempre a partir do preço do item na loja. `basisPoints`: 1500 = 15%. */
+export type OfferPrice = {
+    type: 'fixed';
+    amount: Cents;
+} | {
+    type: 'percent_off';
+    basisPoints: number;
+} | {
+    type: 'amount_off';
+    amount: Cents;
+};
+/** `add` soma o item; `replace` troca o item que disparou a oferta (30 → 90 dias). */
+export type OfferAction = 'add' | 'replace';
+export interface OfferContent {
+    title?: string;
+    body?: string;
+    cta?: string;
+    imageUrl?: string;
+}
+export interface Offer {
+    /** Único por posição; o mesmo id pode viver em duas posições (ofertas migradas do app, ADR 0028 de lá). */
+    id: string;
+    placement: string;
+    /** Desligada não aparece; um teste pode ligá-la numa variante. */
+    active: boolean;
+    /** Menor primeiro; empate fica na ordem do documento. */
+    priority: number;
+    item: ItemRef;
+    price: OfferPrice;
+    action: OfferAction;
+    content: OfferContent;
+    /** Nome do visual que a ponte implementa; sem ele vale o da posição. */
+    presentation?: string;
+    conditions: OfferCondition[];
+    /** Instantes ISO com offset; início inclusivo, fim exclusivo. */
+    validFrom?: string;
+    validUntil?: string;
+}
+/** Apresentação de grupo: com um destes escolhido e todas as vagas no carrinho, as ofertas viram um card só (combo). */
+export interface PlacementGrouping {
+    presentation: string;
+    when: ProductMatch;
+}
+export interface Placement {
+    /** Chave livre da org: `cart`, `checkout`, `product_page`, `add_popup`. */
+    key: string;
+    slots: number;
+    /** Vaga extra condicional: abre só quando o carrinho escolhido casa (a 2ª vaga da Meno). */
+    extraSlot?: {
+        when: ProductMatch;
+    };
+    /** As apresentações que a ponte implementa nesta posição. */
+    presentations: string[];
+    /** Apresentação padrão das ofertas desta posição. */
+    presentation?: string;
+    groupings?: PlacementGrouping[];
+}
+/** O que uma variante de teste muda numa oferta. Campo ausente = igual ao documento. */
+export interface OfferOverride {
+    offerId: string;
+    active?: boolean;
+    price?: OfferPrice;
+    content?: OfferContent;
+    presentation?: string;
+}
+export interface ExperimentVariant {
+    key: string;
+    /** Somam 100 no teste; a ordem não muda com o teste rodando. */
+    percentage: number;
+    offers: OfferOverride[];
+    /** Troca a apresentação padrão da posição. */
+    presentation?: string;
+    /** Troca as apresentações de grupo da posição (`[]` desliga o combo). */
+    groupings?: PlacementGrouping[];
+}
+export interface Experiment {
+    key: string;
+    placement: string;
+    active: boolean;
+    /** Quanto do tráfego entra no teste (0–100); o resto vê o documento sem mudança e não é contado. */
+    percentage: number;
+    /** Sal do sorteio; vazio = igual ao PostHog. */
+    salt?: string;
+    variants: ExperimentVariant[];
+}
+/** Grupo de fora geral: quem cai nele não entra em teste nenhum. Nasce desligado. */
+export interface Holdout {
+    enabled: boolean;
+    percentage: number;
+    salt?: string;
+}
+export interface OfferDocument {
+    /** Formato do documento (começa em 1); o pacote recusa formato mais novo que `SUPPORTED_SCHEMA_VERSION`. */
+    schemaVersion: number;
+    /** Número da versão publicada; a ponte confirma qual está no ar (ADR-0083 §6). */
+    version: number;
+    /** ISO 4217; todo valor em centavos do documento é nesta moeda. */
+    currency: string;
+    items: OfferItem[];
+    placements: Placement[];
+    offers: Offer[];
+    experiments: Experiment[];
+    holdout: Holdout;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * Tipos do motor de ofertas (ADR-0083). O documento publicado é a única entrada de `decide()` e `price()`: a API do
+ * Commerce OS e a ponte de cada loja (avaliação local, Shopify Function) rodam o mesmo código com o mesmo documento.
+ *
+ * Dinheiro: **centavos inteiros** (unidade menor da moeda do documento) em todo lugar do pacote. Nada de float: a
+ * Function cobra o que o pacote calcula, e 79,90 em float vira 79,899999. O arredondamento é explícito em `money.ts`.
+ */
+export {};

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@zolve/offers",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Motor de ofertas headless (ADR-0083): tipos do documento publicado, decide() e price(), sorteio A/B do PostHog. Sem dependências de runtime, para caber numa Shopify Function",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint -c ../../oxlint.json src/",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "oxlint": "^1.58.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}