@owask/tapace-templates 0.0.0-stage → 0.1.0

package/dist/contract/event.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { type EventDateFormat, type EventTimeValue, type FieldDef, type GoogleRole } from './fields.js';
+/**
+ * An event ticket template's live event: kept on the template row, outside
+ * revisions, and pushed to every issued pass when saved. Every part is optional.
+ */
+export declare const EventDetailsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    venue: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+        location: z.ZodOptional<z.ZodObject<{
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    doorsOpen: z.ZodOptional<z.ZodString>;
+    start: z.ZodOptional<z.ZodString>;
+    end: z.ZodOptional<z.ZodString>;
+    doorsOpenLabel: z.ZodOptional<z.ZodEnum<{
+        doorsOpen: "doorsOpen";
+        gatesOpen: "gatesOpen";
+    }>>;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type EventDetails = z.infer<typeof EventDetailsSchema>;
+/** A template's stored event details; anything unreadable counts as none. */
+export declare function storedEvent(raw: unknown): EventDetails | undefined;
+export declare const MAX_CARD_ROWS = 3;
+export declare const MAX_CARD_ROW_ITEMS = 3;
+export type SeatRole = Exclude<GoogleRole, 'ticketType'>;
+/**
+ * A card row item: a field's text, an event time (`event.<time>:<format>`) or a
+ * seat value (`seat.<role>`). Event-time and seat-role fields resolve to the
+ * same built-in items. Undefined for an unknown key or a field the Google
+ * ticket already shows (event name, venue, ticket type).
+ */
+export type CardItem = {
+    kind: 'field';
+    field: FieldDef;
+} | {
+    kind: 'event';
+    event: EventTimeValue;
+    format: EventDateFormat;
+} | {
+    kind: 'seat';
+    role: SeatRole;
+};
+export declare function cardItemRef(item: CardItem): string;
+export declare function resolveCardItem(ref: string, fields: readonly FieldDef[]): CardItem | undefined;
+/** Google's card-front rows on an event ticket, each 1–3 items. */
+export declare const CardRowsSchema: z.ZodArray<z.ZodArray<z.ZodString>>;
+export type CardRows = z.infer<typeof CardRowsSchema>;

package/dist/contract/event.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { EVENT_TIME_VALUES, FieldKeySchema, isEventTime, } from './fields.js';
+import { DateTimeSchema, isTimeZone } from './relevance.js';
+/**
+ * An event ticket template's live event: kept on the template row, outside
+ * revisions, and pushed to every issued pass when saved. Every part is optional.
+ */
+export const EventDetailsSchema = z
+    .strictObject({
+    name: z.string().trim().min(1).max(120).optional(),
+    venue: z
+        .strictObject({
+        name: z.string().trim().min(1).max(120).optional(),
+        address: z.string().trim().min(1).max(300).optional(),
+        location: z
+            .strictObject({
+            latitude: z.number().min(-90).max(90),
+            longitude: z.number().min(-180).max(180),
+        })
+            .optional(),
+    })
+        .optional(),
+    doorsOpen: DateTimeSchema.optional(),
+    start: DateTimeSchema.optional(),
+    end: DateTimeSchema.optional(),
+    doorsOpenLabel: z.enum(['doorsOpen', 'gatesOpen']).optional(),
+    timezone: z.string().refine(isTimeZone, 'Expected a timezone like Asia/Colombo.').optional(),
+})
+    .superRefine((event, ctx) => {
+    const times = EVENT_TIME_VALUES.filter((key) => event[key] !== undefined);
+    for (let i = 1; i < times.length; i++) {
+        const before = times[i - 1];
+        const after = times[i];
+        if (Date.parse(event[after]) < Date.parse(event[before])) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `${TIME_LABELS[after]} can't be before ${TIME_LABELS[before].toLowerCase()}.`,
+                path: [after],
+            });
+        }
+    }
+});
+/** A template's stored event details; anything unreadable counts as none. */
+export function storedEvent(raw) {
+    const parsed = EventDetailsSchema.safeParse(raw);
+    return parsed.success ? parsed.data : undefined;
+}
+const TIME_LABELS = {
+    doorsOpen: 'Doors open',
+    start: 'Start',
+    end: 'End',
+};
+export const MAX_CARD_ROWS = 3;
+export const MAX_CARD_ROW_ITEMS = 3;
+const EVENT_ITEM_RE = /^event\.(doorsOpen|start|end):(dateTime|date|time)$/;
+const SEAT_ITEM_RE = /^seat\.(seat|row|section|gate)$/;
+export function cardItemRef(item) {
+    if (item.kind === 'event')
+        return `event.${item.event}:${item.format}`;
+    if (item.kind === 'seat')
+        return `seat.${item.role}`;
+    return item.field.key;
+}
+export function resolveCardItem(ref, fields) {
+    const event = EVENT_ITEM_RE.exec(ref);
+    if (event) {
+        return { kind: 'event', event: event[1], format: event[2] };
+    }
+    const seat = SEAT_ITEM_RE.exec(ref);
+    if (seat)
+        return { kind: 'seat', role: seat[1] };
+    const field = fields.find((f) => f.key === ref);
+    if (!field || field.googleRole === 'ticketType')
+        return undefined;
+    if (field.googleRole)
+        return { kind: 'seat', role: field.googleRole };
+    if (field.binding === 'event') {
+        if (!field.event || !isEventTime(field.event))
+            return undefined;
+        return { kind: 'event', event: field.event, format: field.dateFormat ?? 'dateTime' };
+    }
+    return { kind: 'field', field };
+}
+const CardItemRefSchema = z
+    .string()
+    .refine((ref) => FieldKeySchema.safeParse(ref).success || EVENT_ITEM_RE.test(ref) || SEAT_ITEM_RE.test(ref), 'Expected a field key, "event.<doorsOpen|start|end>:<dateTime|date|time>" or "seat.<seat|row|section|gate>".');
+/** Google's card-front rows on an event ticket, each 1–3 items. */
+export const CardRowsSchema = z
+    .array(z.array(CardItemRefSchema).min(1).max(MAX_CARD_ROW_ITEMS))
+    .min(1)
+    .max(MAX_CARD_ROWS);

package/dist/contract/featured-actions.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const ACTION_ID_RE: RegExp;
+/**
+ * The types that showed on an iOS 27 device. `place` is left out: it never
+ * showed with any of 10 link formats.
+ */
+export declare const FEATURED_ACTION_TYPES: readonly ["viewSchedule", "watchTrailer", "listenToMusic", "call", "addToBalance", "order", "shop", "membershipBenefits", "bookAppointment", "bookCar", "bookFlight", "bookStay", "viewOffersRewards"];
+export type FeaturedActionType = (typeof FEATURED_ACTION_TYPES)[number];
+export declare const MAX_FEATURED_ACTIONS = 2;
+/** Wallet shows `call` only with a `tel:` link and every other type only with `https:`. */
+export declare function featuredActionUrlError(type: FeaturedActionType, url: string): string | null;
+/**
+ * A button Wallet shows below the pass (iOS 27+, Apple only). `binding` says
+ * where the link comes from:
+ * - `fixed` — `url`, the same on every pass.
+ * - `overridable` — `url` unless the pass supplies its own.
+ * - `perPass` — every pass supplies its own; `sampleUrl` is preview-only.
+ */
+export declare const FeaturedActionDefSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    key: z.ZodString;
+    type: z.ZodEnum<{
+        viewSchedule: "viewSchedule";
+        watchTrailer: "watchTrailer";
+        listenToMusic: "listenToMusic";
+        call: "call";
+        addToBalance: "addToBalance";
+        order: "order";
+        shop: "shop";
+        membershipBenefits: "membershipBenefits";
+        bookAppointment: "bookAppointment";
+        bookCar: "bookCar";
+        bookFlight: "bookFlight";
+        bookStay: "bookStay";
+        viewOffersRewards: "viewOffersRewards";
+    }>;
+    binding: z.ZodEnum<{
+        perPass: "perPass";
+        fixed: "fixed";
+        overridable: "overridable";
+    }>;
+    url: z.ZodOptional<z.ZodString>;
+    sampleUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FeaturedActionDef = z.infer<typeof FeaturedActionDefSchema>;

package/dist/contract/featured-actions.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { FieldKeySchema } from './fields.js';
+export const ACTION_ID_RE = /^fa_[A-Za-z0-9_-]{1,64}$/;
+/**
+ * The types that showed on an iOS 27 device. `place` is left out: it never
+ * showed with any of 10 link formats.
+ */
+export const FEATURED_ACTION_TYPES = [
+    'viewSchedule',
+    'watchTrailer',
+    'listenToMusic',
+    'call',
+    'addToBalance',
+    'order',
+    'shop',
+    'membershipBenefits',
+    'bookAppointment',
+    'bookCar',
+    'bookFlight',
+    'bookStay',
+    'viewOffersRewards',
+];
+export const MAX_FEATURED_ACTIONS = 2;
+const TEL_RE = /^tel:\+?[0-9][0-9 ()-]{2,30}$/;
+/** Wallet shows `call` only with a `tel:` link and every other type only with `https:`. */
+export function featuredActionUrlError(type, url) {
+    if (type === 'call') {
+        return TEL_RE.test(url) ? null : 'A call action needs a phone number link like tel:+94112345678.';
+    }
+    try {
+        return new URL(url).protocol === 'https:' ? null : 'The link must start with https://.';
+    }
+    catch {
+        return 'The link must be a valid https:// URL.';
+    }
+}
+/**
+ * A button Wallet shows below the pass (iOS 27+, Apple only). `binding` says
+ * where the link comes from:
+ * - `fixed` — `url`, the same on every pass.
+ * - `overridable` — `url` unless the pass supplies its own.
+ * - `perPass` — every pass supplies its own; `sampleUrl` is preview-only.
+ */
+export const FeaturedActionDefSchema = z
+    .strictObject({
+    id: z.string().regex(ACTION_ID_RE, 'Invalid action id').optional(),
+    key: FieldKeySchema,
+    type: z.enum(FEATURED_ACTION_TYPES),
+    binding: z.enum(['fixed', 'overridable', 'perPass']),
+    url: z.string().max(2048).optional(),
+    sampleUrl: z.string().max(2048).optional(),
+})
+    .superRefine((action, ctx) => {
+    if (action.binding === 'perPass') {
+        if (action.url !== undefined) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'A link set per pass has no template link.',
+                path: ['url'],
+            });
+        }
+    }
+    else if (action.url === undefined) {
+        ctx.addIssue({ code: 'custom', message: 'Add a link for this action.', path: ['url'] });
+    }
+    if (action.sampleUrl !== undefined && action.binding !== 'perPass') {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Only a link set per pass has a sample link.',
+            path: ['sampleUrl'],
+        });
+    }
+    for (const prop of ['url', 'sampleUrl']) {
+        const value = action[prop];
+        if (value === undefined)
+            continue;
+        const message = featuredActionUrlError(action.type, value);
+        if (message)
+            ctx.addIssue({ code: 'custom', message, path: [prop] });
+    }
+});

package/dist/contract/fields.d.ts

@@ -0,0 +1,153 @@
+import { z } from 'zod';
+/**
+ * A field id is stable across revisions of one template. Its full identity is
+ * `(templateId, fieldId)`, so independent templates may use the same local id.
+ */
+export declare const FIELD_ID_RE: RegExp;
+export declare const FieldKeySchema: z.ZodString;
+export declare const EVENT_VALUES: readonly ["name", "venueName", "venueAddress", "doorsOpen", "start", "end"];
+export type EventValue = (typeof EVENT_VALUES)[number];
+export declare const EVENT_TIME_VALUES: readonly ["doorsOpen", "start", "end"];
+export type EventTimeValue = (typeof EVENT_TIME_VALUES)[number];
+export declare const EVENT_DATE_FORMATS: readonly ["dateTime", "date", "time"];
+export type EventDateFormat = (typeof EVENT_DATE_FORMATS)[number];
+/** Google shows these natively on an event ticket; `ticketType` is not a seat value. */
+export declare const GOOGLE_ROLES: readonly ["seat", "row", "section", "gate", "ticketType"];
+export type GoogleRole = (typeof GOOGLE_ROLES)[number];
+export declare function isEventTime(value: EventValue): value is EventTimeValue;
+/**
+ * One field on the pass face. `binding` is the shared-vs-per-holder boundary:
+ * - `shared`  — the value is part of the design (same on every issued pass).
+ * - `perPass` — the value is supplied at issuance; `required` gates it then.
+ * - `event`   — the value comes from the template's live event details (`event`),
+ *   with `dateFormat` for a time; event ticket templates only.
+ * - `stamps`  — the pass's stamp count as "7 / 10"; stamp card templates only.
+ * - `points`  — the pass's balance as "350 / 1,000" (or "350" with no goal);
+ *   points card templates only.
+ * - `stampsLeft` — stamps still to earn, as "3"; stamp card templates only.
+ * - `pointsToGoal` — points still to the goal, as "160"; points card templates
+ *   with a goal only.
+ *
+ * `googleRole` makes a per-pass field Google's native seat, row, section, gate or
+ * ticket type on an event ticket; Apple shows it as an ordinary field.
+ *
+ * `defaultValue` is the production default; `sampleValue` is preview-only and
+ * never persisted into an issued pass. Keeping them apart stops sample data
+ * from leaking into real passes.
+ */
+export declare const FieldDefSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    key: z.ZodString;
+    label: z.ZodString;
+    binding: z.ZodEnum<{
+        shared: "shared";
+        perPass: "perPass";
+        event: "event";
+        stamps: "stamps";
+        points: "points";
+        stampsLeft: "stampsLeft";
+        pointsToGoal: "pointsToGoal";
+    }>;
+    required: z.ZodBoolean;
+    defaultValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    sampleValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    textAlignment: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        center: "center";
+        right: "right";
+        natural: "natural";
+    }>>;
+    event: z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        venueName: "venueName";
+        venueAddress: "venueAddress";
+        doorsOpen: "doorsOpen";
+        start: "start";
+        end: "end";
+    }>>;
+    dateFormat: z.ZodOptional<z.ZodEnum<{
+        date: "date";
+        dateTime: "dateTime";
+        time: "time";
+    }>>;
+    googleRole: z.ZodOptional<z.ZodEnum<{
+        seat: "seat";
+        row: "row";
+        section: "section";
+        gate: "gate";
+        ticketType: "ticketType";
+    }>>;
+}, z.core.$strict>;
+export type FieldDef = z.infer<typeof FieldDefSchema>;
+export declare const MAX_FIELDS = 40;
+export declare const STANDARD_SLOTS: readonly ["header", "primary", "secondary", "auxiliary", "back"];
+export type StandardSlot = (typeof STANDARD_SLOTS)[number];
+export declare const POSTER_SLOTS: readonly ["header", "primary", "footer", "additionalInfo", "back"];
+export type PosterSlot = (typeof POSTER_SLOTS)[number];
+export type FieldSlot = StandardSlot | PosterSlot;
+export type LayoutName = 'standard' | 'poster';
+/**
+ * The Apple style block (`generic` / `eventTicket`) that older iOS shows, and the
+ * basis of the whole Google pass. Caps mirror the wallet layouts; passmint
+ * enforces the authoritative native limits at compile time.
+ */
+export declare const StandardLayoutSchema: z.ZodObject<{
+    header: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    primary: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    secondary: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    auxiliary: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    back: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type StandardLayout = z.infer<typeof StandardLayoutSchema>;
+/** iOS 27 poster layout. Caps are what Wallet showed on an iOS 27 device. */
+export declare const PosterLayoutSchema: z.ZodObject<{
+    header: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    primary: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    footer: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    additionalInfo: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    back: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type PosterLayout = z.infer<typeof PosterLayoutSchema>;
+export declare const FieldListSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    key: z.ZodString;
+    label: z.ZodString;
+    binding: z.ZodEnum<{
+        shared: "shared";
+        perPass: "perPass";
+        event: "event";
+        stamps: "stamps";
+        points: "points";
+        stampsLeft: "stampsLeft";
+        pointsToGoal: "pointsToGoal";
+    }>;
+    required: z.ZodBoolean;
+    defaultValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    sampleValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    textAlignment: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        center: "center";
+        right: "right";
+        natural: "natural";
+    }>>;
+    event: z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        venueName: "venueName";
+        venueAddress: "venueAddress";
+        doorsOpen: "doorsOpen";
+        start: "start";
+        end: "end";
+    }>>;
+    dateFormat: z.ZodOptional<z.ZodEnum<{
+        date: "date";
+        dateTime: "dateTime";
+        time: "time";
+    }>>;
+    googleRole: z.ZodOptional<z.ZodEnum<{
+        seat: "seat";
+        row: "row";
+        section: "section";
+        gate: "gate";
+        ticketType: "ticketType";
+    }>>;
+}, z.core.$strict>>;

package/dist/contract/fields.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { FieldValueSchema, TextAlignmentSchema } from './primitives.js';
+/**
+ * A field id is stable across revisions of one template. Its full identity is
+ * `(templateId, fieldId)`, so independent templates may use the same local id.
+ */
+export const FIELD_ID_RE = /^fld_[A-Za-z0-9_-]{1,64}$/;
+export const FieldKeySchema = z
+    .string()
+    .regex(/^[A-Za-z0-9_]{1,64}$/, 'Field key must be 1–64 chars of [A-Za-z0-9_]');
+export const EVENT_VALUES = ['name', 'venueName', 'venueAddress', 'doorsOpen', 'start', 'end'];
+export const EVENT_TIME_VALUES = ['doorsOpen', 'start', 'end'];
+export const EVENT_DATE_FORMATS = ['dateTime', 'date', 'time'];
+/** Google shows these natively on an event ticket; `ticketType` is not a seat value. */
+export const GOOGLE_ROLES = ['seat', 'row', 'section', 'gate', 'ticketType'];
+export function isEventTime(value) {
+    return EVENT_TIME_VALUES.includes(value);
+}
+/**
+ * One field on the pass face. `binding` is the shared-vs-per-holder boundary:
+ * - `shared`  — the value is part of the design (same on every issued pass).
+ * - `perPass` — the value is supplied at issuance; `required` gates it then.
+ * - `event`   — the value comes from the template's live event details (`event`),
+ *   with `dateFormat` for a time; event ticket templates only.
+ * - `stamps`  — the pass's stamp count as "7 / 10"; stamp card templates only.
+ * - `points`  — the pass's balance as "350 / 1,000" (or "350" with no goal);
+ *   points card templates only.
+ * - `stampsLeft` — stamps still to earn, as "3"; stamp card templates only.
+ * - `pointsToGoal` — points still to the goal, as "160"; points card templates
+ *   with a goal only.
+ *
+ * `googleRole` makes a per-pass field Google's native seat, row, section, gate or
+ * ticket type on an event ticket; Apple shows it as an ordinary field.
+ *
+ * `defaultValue` is the production default; `sampleValue` is preview-only and
+ * never persisted into an issued pass. Keeping them apart stops sample data
+ * from leaking into real passes.
+ */
+export const FieldDefSchema = z
+    .strictObject({
+    id: z.string().regex(FIELD_ID_RE, 'Invalid field id').optional(),
+    key: FieldKeySchema,
+    label: z.string().min(1).max(64),
+    binding: z.enum(['shared', 'perPass', 'event', 'stamps', 'points', 'stampsLeft', 'pointsToGoal']),
+    required: z.boolean(),
+    defaultValue: FieldValueSchema.optional(),
+    sampleValue: FieldValueSchema.optional(),
+    textAlignment: TextAlignmentSchema.optional(),
+    event: z.enum(EVENT_VALUES).optional(),
+    dateFormat: z.enum(EVENT_DATE_FORMATS).optional(),
+    googleRole: z.enum(GOOGLE_ROLES).optional(),
+})
+    .superRefine((f, ctx) => {
+    if (f.binding !== 'perPass' && f.required) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Only a per-pass field can be required (the others have no issue-time input).',
+            path: ['required'],
+        });
+    }
+    if (f.binding === 'event') {
+        if (!f.event) {
+            ctx.addIssue({ code: 'custom', message: 'Pick which event detail this field shows.', path: ['event'] });
+        }
+        if (f.defaultValue !== undefined) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'An event field takes its value from the event details.',
+                path: ['defaultValue'],
+            });
+        }
+        if (f.dateFormat && f.event && !isEventTime(f.event)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'Only an event time has a date format.',
+                path: ['dateFormat'],
+            });
+        }
+    }
+    else if (f.binding === 'stamps' || f.binding === 'stampsLeft') {
+        if (f.defaultValue !== undefined) {
+            ctx.addIssue({
+                code: 'custom',
+                message: f.binding === 'stamps'
+                    ? 'The stamp count field takes its value from the pass.'
+                    : 'The stamps left field takes its value from the pass.',
+                path: ['defaultValue'],
+            });
+        }
+    }
+    else if (f.binding === 'points' || f.binding === 'pointsToGoal') {
+        if (f.defaultValue !== undefined) {
+            ctx.addIssue({
+                code: 'custom',
+                message: f.binding === 'points'
+                    ? 'The points field takes its value from the pass.'
+                    : 'The points to goal field takes its value from the pass.',
+                path: ['defaultValue'],
+            });
+        }
+    }
+    if (f.binding !== 'event' && (f.event !== undefined || f.dateFormat !== undefined)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Only an event field shows an event detail.',
+            path: ['event'],
+        });
+    }
+    if (f.googleRole && f.binding !== 'perPass') {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Only a per-pass field can have a Google role.',
+            path: ['googleRole'],
+        });
+    }
+});
+export const MAX_FIELDS = 40;
+export const STANDARD_SLOTS = ['header', 'primary', 'secondary', 'auxiliary', 'back'];
+export const POSTER_SLOTS = ['header', 'primary', 'footer', 'additionalInfo', 'back'];
+const slotKeys = (max) => z.array(FieldKeySchema).max(max).default([]);
+/**
+ * The Apple style block (`generic` / `eventTicket`) that older iOS shows, and the
+ * basis of the whole Google pass. Caps mirror the wallet layouts; passmint
+ * enforces the authoritative native limits at compile time.
+ */
+export const StandardLayoutSchema = z.strictObject({
+    header: slotKeys(3),
+    primary: slotKeys(1),
+    secondary: slotKeys(2),
+    auxiliary: slotKeys(2),
+    back: slotKeys(20),
+});
+/** iOS 27 poster layout. Caps are what Wallet showed on an iOS 27 device. */
+export const PosterLayoutSchema = z.strictObject({
+    header: slotKeys(1),
+    primary: slotKeys(4),
+    footer: slotKeys(1),
+    additionalInfo: slotKeys(8),
+    back: slotKeys(20),
+});
+export const FieldListSchema = z.array(FieldDefSchema).max(MAX_FIELDS);

package/dist/contract/ids.d.ts

@@ -0,0 +1,2 @@
+/** Same shape as `common/ids` `newId`, using Web Crypto so it also runs in the browser. */
+export declare function newFieldId(prefix: 'fld' | 'fa'): string;

package/dist/contract/ids.js

@@ -0,0 +1,6 @@
+/** Same shape as `common/ids` `newId`, using Web Crypto so it also runs in the browser. */
+export function newFieldId(prefix) {
+    const bytes = crypto.getRandomValues(new Uint8Array(15));
+    const base64 = btoa(String.fromCharCode(...bytes));
+    return `${prefix}_${base64.replace(/\+/g, '-').replace(/\//g, '_')}`;
+}

package/dist/contract/index.d.ts

@@ -0,0 +1,9 @@
+export * from './primitives.js';
+export * from './fields.js';
+export * from './featured-actions.js';
+export * from './relevance.js';
+export * from './event.js';
+export * from './stamps.js';
+export * from './points.js';
+export * from './definition.js';
+export * from './upgrade.js';

package/dist/contract/index.js

@@ -0,0 +1,9 @@
+export * from './primitives.js';
+export * from './fields.js';
+export * from './featured-actions.js';
+export * from './relevance.js';
+export * from './event.js';
+export * from './stamps.js';
+export * from './points.js';
+export * from './definition.js';
+export * from './upgrade.js';

package/dist/contract/points.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+/** The largest balance, limit or change a points card stores (`DECIMAL(9,2)`). */
+export declare const MAX_POINTS = 9999999.99;
+export declare const PointsAmountSchema: z.ZodNumber;
+/**
+ * A points card's range and starting balance. Every limit is optional. The goal
+ * caps the balance; `max` only limits it when there is no goal, so a goal above
+ * it is rejected rather than ignored.
+ */
+export declare const PointsSettingsSchema: z.ZodObject<{
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    goal: z.ZodOptional<z.ZodNumber>;
+    starting: z.ZodNumber;
+}, z.core.$strict>;
+export type PointsSettings = z.infer<typeof PointsSettingsSchema>;
+/**
+ * What a points change that notifies says. `{balance}` stands for the balance
+ * text ("350 / 1,000") and `{change}` for the requested amount ("+50"). Apple's
+ * message is the points field's change message, so it must contain `{balance}`;
+ * without a points field it fills the pass's message field instead. The optional
+ * `goal…` texts replace them when the change reaches the goal; Apple's always
+ * goes in the message field, so it needs no `{balance}`.
+ */
+export declare const PointsNotificationsSchema: z.ZodObject<{
+    apple: z.ZodOptional<z.ZodString>;
+    googleTitle: z.ZodOptional<z.ZodString>;
+    googleBody: z.ZodOptional<z.ZodString>;
+    goalApple: z.ZodOptional<z.ZodString>;
+    goalGoogleTitle: z.ZodOptional<z.ZodString>;
+    goalGoogleBody: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PointsNotifications = z.infer<typeof PointsNotificationsSchema>;
+/** The highest balance: the goal when set, else the maximum. */
+export declare function pointsCap(points: Pick<PointsSettings, 'goal' | 'max'>): number | undefined;
+/** "1,250", "12.50", "-9,999,999.99": decimals only on numbers that have them. */
+export declare function formatPoints(value: number): string;
+/** "350 / 1,000" with a goal, "350" without. */
+export declare function pointsBalanceText(balance: number, goal: number | undefined): string;
+/** A change with its sign: "+50", "−20" (a true minus, as device-tested). */
+export declare function pointsChangeText(change: number): string;