@signstack/cli 0.1.1

package/dist/libs/signstack/base/src/lib/models/marketplace-listing.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListingPreviewsStatus = exports.MarketplaceListingScope = void 0;
+var MarketplaceListingScope;
+(function (MarketplaceListingScope) {
+    MarketplaceListingScope["Public"] = "public";
+    MarketplaceListingScope["Org"] = "org";
+})(MarketplaceListingScope || (exports.MarketplaceListingScope = MarketplaceListingScope = {}));
+/**
+ * Generation state of a listing's scenario previews. Publishing returns
+ * immediately (202) with `pending`; per-scenario renders run as background
+ * jobs and the state flips to `ready` once all previews + hero image are
+ * generated. `failed` is reserved for a hard finalization failure. The
+ * library UI polls the listing until this is terminal.
+ */
+var ListingPreviewsStatus;
+(function (ListingPreviewsStatus) {
+    ListingPreviewsStatus["Pending"] = "pending";
+    ListingPreviewsStatus["Ready"] = "ready";
+    ListingPreviewsStatus["Failed"] = "failed";
+})(ListingPreviewsStatus || (exports.ListingPreviewsStatus = ListingPreviewsStatus = {}));
+//# sourceMappingURL=marketplace-listing.js.map

package/dist/libs/signstack/base/src/lib/models/marketplace-listing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-listing.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/marketplace-listing.ts"],"names":[],"mappings":";;;AAQA,IAAY,uBAGX;AAHD,WAAY,uBAAuB;IACjC,4CAAiB,CAAA;IACjB,sCAAW,CAAA;AACb,CAAC,EAHW,uBAAuB,uCAAvB,uBAAuB,QAGlC;AAiED;;;;;;GAMG;AACH,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,4CAAmB,CAAA;IACnB,wCAAe,CAAA;IACf,0CAAiB,CAAA;AACnB,CAAC,EAJW,qBAAqB,qCAArB,qBAAqB,QAIhC"}

package/dist/libs/signstack/base/src/lib/models/membership.d.ts

@@ -0,0 +1,127 @@
+import { PaginationDto } from './base';
+import { OrganizationRole } from './organization';
+export declare enum NamespaceRole {
+    Admin = "admin",
+    Editor = "editor",
+    Viewer = "viewer"
+}
+export declare enum MembershipScopeLevel {
+    Org = "org",
+    Namespace = "namespace"
+}
+export interface Membership {
+    userId: string;
+    orgId: string;
+    scopeLevel: MembershipScopeLevel;
+    namespaceKey?: string;
+    roles: (OrganizationRole | NamespaceRole)[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare enum InvitationStatus {
+    Pending = "pending",
+    Accepted = "accepted",
+    Rejected = "rejected",
+    Revoked = "revoked"
+}
+export type InvitationActionType = Exclude<InvitationStatus, InvitationStatus.Pending>;
+export interface InvitationActionTaken {
+    action: InvitationActionType;
+    at: string;
+    by: string;
+}
+export interface Invitation {
+    id: string;
+    email: string;
+    orgId: string;
+    scopeLevel: MembershipScopeLevel;
+    namespaceKey?: string;
+    roles: (OrganizationRole | NamespaceRole)[];
+    status: InvitationStatus;
+    invitedBy: string;
+    actionTaken?: InvitationActionTaken;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface OrgAccessClaim {
+    orgId: string;
+    orgRoles: OrganizationRole[];
+    namespaceKey?: string;
+    namespaceRoles?: NamespaceRole[];
+}
+export interface SendInvitationReq {
+    email: string;
+    scopeLevel: MembershipScopeLevel;
+    /** Required iff `scopeLevel === MembershipScopeLevel.Namespace`. */
+    namespaceKey?: string;
+    roles: (OrganizationRole | NamespaceRole)[];
+}
+export interface SendInvitationResp {
+    invitationId: string;
+}
+export interface UpdateInvitationReq {
+    status: InvitationStatus;
+}
+export interface UpdateInvitationResp {
+}
+export interface InvitationResp extends Invitation {
+    org?: {
+        name: string;
+    };
+    namespace?: {
+        name: string;
+    };
+    _eTag?: string;
+}
+export type GetInvitationResp = InvitationResp;
+/**
+ * Shared pagination + search query for member / invitation list endpoints.
+ * The BE applies sensible defaults (offset 0, limit 25, no search) when any
+ * field is omitted.
+ */
+export interface ListMembersReq {
+    search?: string;
+    offset?: number;
+    limit?: number;
+}
+export type ListInvitationsReq = ListMembersReq;
+export interface GetInvitationsResp {
+    invitations: InvitationResp[];
+    pagination: PaginationDto;
+}
+export interface GetMyInvitationsResp {
+    invitations: InvitationResp[];
+}
+export interface MemberResp {
+    uid: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    scopeLevel: MembershipScopeLevel;
+    namespaceKey?: string;
+    roles: (OrganizationRole | NamespaceRole)[];
+    removedAt?: string;
+    removedBy?: string;
+}
+export interface GetMembersResp {
+    members: MemberResp[];
+    pagination: PaginationDto;
+    /**
+     * Org Owners + Admins who have implicit access to the namespace via their
+     * org role (no explicit namespace-scope row). Only populated on the
+     * namespace-scope members endpoint, and intentionally NOT paginated —
+     * typically a small handful per org. UI renders these in a read-only
+     * "Inherited from organization" section.
+     */
+    inheritedOrgAdmins?: MemberResp[];
+}
+export type GetMyAccessResp = OrgAccessClaim;
+export interface UpdateMemberRolesReq {
+    scopeLevel: MembershipScopeLevel;
+    namespaceKey?: string;
+    roles: (OrganizationRole | NamespaceRole)[];
+}
+export interface UpdateMemberRolesResp {
+}
+export interface RemoveMemberResp {
+}

package/dist/libs/signstack/base/src/lib/models/membership.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvitationStatus = exports.MembershipScopeLevel = exports.NamespaceRole = void 0;
+var NamespaceRole;
+(function (NamespaceRole) {
+    NamespaceRole["Admin"] = "admin";
+    NamespaceRole["Editor"] = "editor";
+    NamespaceRole["Viewer"] = "viewer";
+})(NamespaceRole || (exports.NamespaceRole = NamespaceRole = {}));
+var MembershipScopeLevel;
+(function (MembershipScopeLevel) {
+    MembershipScopeLevel["Org"] = "org";
+    MembershipScopeLevel["Namespace"] = "namespace";
+})(MembershipScopeLevel || (exports.MembershipScopeLevel = MembershipScopeLevel = {}));
+var InvitationStatus;
+(function (InvitationStatus) {
+    InvitationStatus["Pending"] = "pending";
+    InvitationStatus["Accepted"] = "accepted";
+    InvitationStatus["Rejected"] = "rejected";
+    InvitationStatus["Revoked"] = "revoked";
+})(InvitationStatus || (exports.InvitationStatus = InvitationStatus = {}));
+//# sourceMappingURL=membership.js.map

package/dist/libs/signstack/base/src/lib/models/membership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"membership.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/membership.ts"],"names":[],"mappings":";;;AAGA,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,kCAAiB,CAAA;IACjB,kCAAiB,CAAA;AACnB,CAAC,EAJW,aAAa,6BAAb,aAAa,QAIxB;AAED,IAAY,oBAGX;AAHD,WAAY,oBAAoB;IAC9B,mCAAW,CAAA;IACX,+CAAuB,CAAA;AACzB,CAAC,EAHW,oBAAoB,oCAApB,oBAAoB,QAG/B;AAYD,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,uCAAmB,CAAA;IACnB,yCAAqB,CAAA;IACrB,yCAAqB,CAAA;IACrB,uCAAmB,CAAA;AACrB,CAAC,EALW,gBAAgB,gCAAhB,gBAAgB,QAK3B"}

package/dist/libs/signstack/base/src/lib/models/namespace.d.ts

@@ -0,0 +1,87 @@
+import { PaginationDto } from './base';
+import { BrandSettings } from './organization';
+/**
+ * Namespace model types
+ *
+ * Namespaces allow organizations to create isolated environments for
+ * multi-tenant use cases. Each namespace has a mode (test/live) that
+ * determines billing and API key behavior.
+ */
+export declare enum NamespaceMode {
+    Test = "test",
+    Live = "live"
+}
+/**
+ * Regex for validating namespace keys:
+ * - Must start and end with alphanumeric character
+ * - Can contain lowercase letters, numbers, and hyphens
+ * - Length: 3-50 characters
+ */
+export declare const NAMESPACE_KEY_REGEX: RegExp;
+/**
+ * Default namespace key created for each organization
+ */
+export declare const DEFAULT_TEST_NAMESPACE = "default-test";
+/**
+ * Reserved namespace keys that cannot be used by customers
+ */
+export declare const RESERVED_NAMESPACE_KEYS: string[];
+/**
+ * Validates a namespace key against format and reserved name rules
+ */
+export declare function isValidNamespaceKey(key: string): boolean;
+/**
+ * Request to create a new namespace
+ */
+export interface CreateNamespaceReq {
+    key: string;
+    name: string;
+    mode: NamespaceMode;
+    /** Omit when no branding on create. */
+    settings?: BrandSettings;
+}
+/**
+ * Request to update an existing namespace (only name is editable)
+ */
+export interface UpdateNamespaceReq {
+    name: string;
+    settings?: BrandSettings;
+}
+/**
+ * Full namespace — returned by `GET /orgs/{orgId}/namespaces/{namespaceKey}`,
+ * `POST /orgs/{orgId}/namespaces`, and `PATCH /orgs/{orgId}/namespaces/{namespaceKey}`.
+ * The optimistic-locking handle is on the `ETag` HTTP response header
+ * (RFC 7232) — pass it back as `If-Match` on the next `PATCH`.
+ */
+export interface NamespaceResp {
+    key: string;
+    name: string;
+    mode: NamespaceMode;
+    settings?: BrandSettings;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Namespace list item — carries `_eTag` per item since list responses cannot
+ * use the `ETag` header (one header, many items).
+ */
+export interface NamespaceListItem extends NamespaceResp {
+    _eTag?: string;
+}
+/**
+ * List namespaces request — supports search + pagination so the switcher
+ * scales to orgs with many thousands of namespaces. All fields optional;
+ * the BE applies defaults (offset 0, limit 25, no search filter).
+ */
+export interface ListNamespacesReq {
+    search?: string;
+    offset?: number;
+    limit?: number;
+}
+/**
+ * List namespaces response
+ */
+export interface ListNamespacesResp {
+    data: NamespaceListItem[];
+    pagination: PaginationDto;
+}

package/dist/libs/signstack/base/src/lib/models/namespace.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESERVED_NAMESPACE_KEYS = exports.DEFAULT_TEST_NAMESPACE = exports.NAMESPACE_KEY_REGEX = exports.NamespaceMode = void 0;
+exports.isValidNamespaceKey = isValidNamespaceKey;
+/**
+ * Namespace model types
+ *
+ * Namespaces allow organizations to create isolated environments for
+ * multi-tenant use cases. Each namespace has a mode (test/live) that
+ * determines billing and API key behavior.
+ */
+var NamespaceMode;
+(function (NamespaceMode) {
+    NamespaceMode["Test"] = "test";
+    NamespaceMode["Live"] = "live";
+})(NamespaceMode || (exports.NamespaceMode = NamespaceMode = {}));
+/**
+ * Regex for validating namespace keys:
+ * - Must start and end with alphanumeric character
+ * - Can contain lowercase letters, numbers, and hyphens
+ * - Length: 3-50 characters
+ */
+exports.NAMESPACE_KEY_REGEX = /^[a-z0-9][a-z0-9-]{1,48}[a-z0-9]$/;
+/**
+ * Default namespace key created for each organization
+ */
+exports.DEFAULT_TEST_NAMESPACE = 'default-test';
+/**
+ * Reserved namespace keys that cannot be used by customers
+ */
+exports.RESERVED_NAMESPACE_KEYS = [
+    'admin',
+    'api',
+    'system',
+    'internal',
+    'default',
+    'test',
+    'live',
+    'prod',
+    'production',
+    'staging',
+    'dev',
+    'development',
+];
+/**
+ * Validates a namespace key against format and reserved name rules
+ */
+function isValidNamespaceKey(key) {
+    if (!exports.NAMESPACE_KEY_REGEX.test(key)) {
+        return false;
+    }
+    if (exports.RESERVED_NAMESPACE_KEYS.includes(key)) {
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=namespace.js.map

package/dist/libs/signstack/base/src/lib/models/namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/namespace.ts"],"names":[],"mappings":";;;AAiDA,kDAQC;AAtDD;;;;;;GAMG;AACH,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,8BAAa,CAAA;AACf,CAAC,EAHW,aAAa,6BAAb,aAAa,QAGxB;AAED;;;;;GAKG;AACU,QAAA,mBAAmB,GAAG,mCAAmC,CAAC;AAEvE;;GAEG;AACU,QAAA,sBAAsB,GAAG,cAAc,CAAC;AAErD;;GAEG;AACU,QAAA,uBAAuB,GAAG;IACrC,OAAO;IACP,KAAK;IACL,QAAQ;IACR,UAAU;IACV,SAAS;IACT,MAAM;IACN,MAAM;IACN,MAAM;IACN,YAAY;IACZ,SAAS;IACT,KAAK;IACL,aAAa;CACd,CAAC;AAEF;;GAEG;AACH,SAAgB,mBAAmB,CAAC,GAAW;IAC7C,IAAI,CAAC,2BAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,+BAAuB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/libs/signstack/base/src/lib/models/organization.d.ts

@@ -0,0 +1,79 @@
+import { UploadFile } from './base';
+export declare const BrandSettingsKeys: string[];
+/**
+ * Org-level roles a user can hold on an organization.
+ *
+ *   - `Owner` — strict superset of everything; can transfer or delete the
+ *     org; can't be removed by anyone but themselves.
+ *   - `Admin` — manages members, namespaces, settings; implicit access to
+ *     every namespace in the org.
+ *   - `Billing` — billing and plan only; no namespace access.
+ */
+export declare enum OrganizationRole {
+    Owner = "owner",
+    Admin = "admin",
+    Billing = "billing"
+}
+/**
+ * Brand settings for sender branding.
+ *
+ * `logoUrl` carries either a persisted URL (after upload) or an unresolved
+ * `UploadFile` on the client while the user is still editing the form. The
+ * client's update helpers are responsible for uploading the file and
+ * rewriting this field before it reaches the wire.
+ */
+export interface BrandSettings {
+    senderName: string;
+    company: string;
+    contactEmail: string;
+    logoFileId: string;
+    logoUrl?: string | UploadFile;
+    senderEmail?: string;
+    senderEmailVerified?: boolean;
+    phone?: string;
+    address?: string;
+}
+/**
+ * Brand fields that must all be populated for a level (namespace/org) to
+ * count as having sender branding "set up". When all three are present the
+ * level supplies the entire `SenderInfo`; otherwise the lookup falls through
+ * to the next level (org → defaults). Sender-email verification keys are
+ * deliberately excluded — they belong to a separate flow and don't imply
+ * branding is configured.
+ */
+export declare const RequiredBrandSettingsKeys: Array<keyof BrandSettings>;
+/**
+ * Full organization — returned by `POST /orgs` and `PUT /orgs/{orgId}`. The
+ * optimistic-locking handle is on the `ETag` HTTP response header (RFC 7232) —
+ * pass it back as `If-Match` on the next `PUT`.
+ */
+export interface OrganizationResp {
+    /** Prefixed lowercase ULID, e.g. `org_01jv8m7qfj6xj9gkz7a4s2h8e`. */
+    orgId: string;
+    name: string;
+    ownerId: string;
+    settings?: BrandSettings;
+    updatedAt: string;
+}
+/**
+ * Organization list item — returned by `POST /orgs/list`. Carries `_eTag`
+ * in the body because list responses can't multiplex per-item `ETag` headers.
+ */
+export interface OrganizationListItem extends OrganizationResp {
+    _eTag?: string;
+}
+export interface GetOrganizationsResp {
+    data: OrganizationListItem[];
+}
+export interface CreateOrganizationReq {
+    name: string;
+    /**
+     * Omit when no branding is desired on create.
+     * Send `null` from an update flow to clear previously-saved branding.
+     */
+    settings?: BrandSettings | null;
+}
+export interface UpdateOrganizationReq {
+    name: string;
+    settings?: BrandSettings;
+}

package/dist/libs/signstack/base/src/lib/models/organization.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredBrandSettingsKeys = exports.OrganizationRole = exports.BrandSettingsKeys = void 0;
+exports.BrandSettingsKeys = [
+    'senderName',
+    'senderEmail',
+    'contactEmail',
+    'phone',
+    'address',
+    'logoUrl',
+];
+/**
+ * Org-level roles a user can hold on an organization.
+ *
+ *   - `Owner` — strict superset of everything; can transfer or delete the
+ *     org; can't be removed by anyone but themselves.
+ *   - `Admin` — manages members, namespaces, settings; implicit access to
+ *     every namespace in the org.
+ *   - `Billing` — billing and plan only; no namespace access.
+ */
+var OrganizationRole;
+(function (OrganizationRole) {
+    OrganizationRole["Owner"] = "owner";
+    OrganizationRole["Admin"] = "admin";
+    OrganizationRole["Billing"] = "billing";
+})(OrganizationRole || (exports.OrganizationRole = OrganizationRole = {}));
+/**
+ * Brand fields that must all be populated for a level (namespace/org) to
+ * count as having sender branding "set up". When all three are present the
+ * level supplies the entire `SenderInfo`; otherwise the lookup falls through
+ * to the next level (org → defaults). Sender-email verification keys are
+ * deliberately excluded — they belong to a separate flow and don't imply
+ * branding is configured.
+ */
+exports.RequiredBrandSettingsKeys = [
+    'senderName',
+    'company',
+    'contactEmail',
+    'logoUrl'
+];
+//# sourceMappingURL=organization.js.map

package/dist/libs/signstack/base/src/lib/models/organization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"organization.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/organization.ts"],"names":[],"mappings":";;;AAEa,QAAA,iBAAiB,GAAG;IAC/B,YAAY;IACZ,aAAa;IACb,cAAc;IACd,OAAO;IACP,SAAS;IACT,SAAS;CACV,CAAC;AAEF;;;;;;;;GAQG;AACH,IAAY,gBAIX;AAJD,WAAY,gBAAgB;IAC1B,mCAAe,CAAA;IACf,mCAAe,CAAA;IACf,uCAAmB,CAAA;AACrB,CAAC,EAJW,gBAAgB,gCAAhB,gBAAgB,QAI3B;AAsBD;;;;;;;GAOG;AACU,QAAA,yBAAyB,GAA+B;IACnE,YAAY;IACZ,SAAS;IACT,cAAc;IACd,SAAS;CACV,CAAC"}

package/dist/libs/signstack/base/src/lib/models/render-job.d.ts

@@ -0,0 +1,88 @@
+import { RenderBlueprintResp } from './blueprint';
+import { RenderTemplateResp } from './template';
+/**
+ * Async render-job models shared across backend, frontend clients, and CLI.
+ *
+ * Background: render endpoints are moving from a synchronous long-poll
+ * (the backend blocked the request until the pipeline finished) to an
+ * accept-then-poll contract. Public render endpoints return `{ jobId(s) }`
+ * immediately; clients poll the status endpoint until the job reaches a
+ * terminal state, then read `result`.
+ *
+ * Phase A adds these types + the status endpoint. The `Accepted` response
+ * shapes and the FE polling clients land in Phase B.
+ */
+/** Terminal + in-flight states a render job can report. Mirrors the
+ * backend `RenderJobStatus` enum string values. */
+export type RenderJobStatusValue = 'pending' | 'rendering' | 'completed' | 'failed';
+/** Which kind of caller produced the job. Mirrors backend `RenderJobKind`. */
+export type RenderJobKindValue = 'blueprint' | 'template';
+/**
+ * Terminal result of a render job, discriminated by the job's `kind`:
+ * template-kind jobs resolve to `RenderTemplateResp`, blueprint-kind jobs
+ * to `RenderBlueprintResp`. Only present once `status === 'completed'`.
+ */
+export type RenderJobResult = RenderTemplateResp | RenderBlueprintResp;
+/**
+ * Response of `GET …/render-jobs/:jobId` — the polling target that
+ * replaces the old synchronous `awaitCompletion` long-poll. Clients poll
+ * this until `status` is terminal (`completed` | `failed`), then read
+ * `result` (on success) or `error` (on failure).
+ */
+export interface GetRenderJobResp {
+    jobId: string;
+    kind: RenderJobKindValue;
+    /** Present for blueprint-kind jobs; one job renders one envelope. */
+    envelopeKey?: string;
+    status: RenderJobStatusValue;
+    /** Set when `status === 'failed'` — carries the first failure. */
+    error?: string;
+    /** Set when `status === 'completed'` — the rendered output. */
+    result?: RenderJobResult;
+}
+/**
+ * "Do X when render-job Y completes." Persisted on the render job so the
+ * render-events webhook can drive post-render work without the caller
+ * blocking on the result. This is the immutable DESCRIPTOR of the work;
+ * its run lifecycle is tracked separately on `continuationStatus` /
+ * `continuationError`. Handlers register by `kind` with the dispatcher.
+ */
+export type RenderContinuation = {
+    kind: 'workflow-signed-envelope';
+    workflowId: string;
+    envelopeKey: string;
+    /** Participant step whose signed document this render produces. */
+    stepKey: string;
+    /** Path-in-bucket to upload the combined, finalized signed PDF to. */
+    outputGcsPath: string;
+    hashAlgorithm: 'sha256';
+} | {
+    /**
+     * The whole envelope is signed by everyone. When this render
+     * completes, build the final signed PDF, generate the signing
+     * certificate, email all participants, fire the envelope-completed
+     * webhook, and persist the signed document on the envelope.
+     */
+    kind: 'workflow-envelope-completion';
+    workflowId: string;
+    envelopeKey: string;
+} | {
+    kind: 'marketplace-listing-preview';
+    listingId: string;
+    scenarioId: string;
+    /** Carried on the job so the handler can label the preview file
+     * without the listing storing a per-job tracker. */
+    scenarioName: string;
+    previewIndex: number;
+};
+/**
+ * Run lifecycle of a job's continuation, tracked top-level on the job for
+ * race-safe atomic claims (mirrors how `status` tracks the render itself):
+ *  - `pending`  — continuation persisted, not yet dispatched
+ *  - `running`  — a dispatcher claimed it (idempotency guard against
+ *                 render-events re-delivery)
+ *  - `done`     — handler finished successfully
+ *  - `failed`   — handler threw; see `continuationError`. The render itself
+ *                 stays `completed` — only the post-render work failed.
+ */
+export type RenderContinuationStatus = 'pending' | 'running' | 'done' | 'failed';

package/dist/libs/signstack/base/src/lib/models/render-job.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=render-job.js.map

package/dist/libs/signstack/base/src/lib/models/render-job.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-job.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/render-job.ts"],"names":[],"mappings":""}

package/dist/libs/signstack/base/src/lib/models/resource-edge.d.ts

@@ -0,0 +1,60 @@
+import type { TemplateSpec } from './template';
+import type { AssetSpec } from './asset';
+import type { JsonataFunctionSpec } from './jsonata-function';
+import type { BlueprintSpec } from './blueprint';
+export declare enum ResourceKind {
+    Blueprint = "blueprint",
+    Template = "template",
+    Schema = "schema",
+    Asset = "asset",
+    JsonataFunction = "jsonata_function"
+}
+export declare function toResourceCascadeKey(kind: ResourceKind | string, key: string): string;
+export declare function parseResourceCascadeKey(resourceCascadeKey: string): {
+    kind: ResourceKind;
+    key: string;
+};
+export declare function toResourceId(kind: ResourceKind | string, key: string, version: string): string;
+export declare function parseResourceId(resourceId: string): {
+    kind: ResourceKind;
+    key: string;
+    version: string;
+};
+export interface ResourceEdge {
+    sourceId: string;
+    targetId: string;
+}
+export interface ResourceDependencyNode {
+    resourceId: string;
+    children: ResourceDependencyNode[];
+}
+export interface GetResourceDependenciesResp {
+    resourceId: string;
+    edges: ResourceEdge[];
+}
+export interface GetResourceDependencyTreeResp {
+    tree: ResourceDependencyNode;
+}
+export interface ResourceDep {
+    kind: ResourceKind;
+    key: string;
+    version: string;
+}
+/** Template spec → direct deps: content asset, functions, input schemas. */
+export declare function getTemplateDeps(spec: TemplateSpec): ResourceDep[];
+/** Asset spec → direct deps: sub-assets (partials/images/styles), viewModelSchema. */
+export declare function getAssetDeps(spec: AssetSpec): ResourceDep[];
+/** Function spec → direct deps: param schemas, returnType schema. */
+export declare function getFunctionDeps(spec: JsonataFunctionSpec): ResourceDep[];
+/** Blueprint spec → direct deps: functions, input schemas, envelope templates. */
+export declare function getBlueprintDeps(spec: BlueprintSpec): ResourceDep[];
+/**
+ * Collect all transitive deps starting from a template spec.
+ * Walks: template → (assets, functions, schemas) → (sub-assets, function schemas) → ...
+ * Uses lookup functions to resolve specs for intermediate resources.
+ * Returns deduplicated flat array of all deps (direct + transitive).
+ */
+export declare function collectTransitiveDeps(templateSpec: TemplateSpec, lookups: {
+    getAssetSpec?: (key: string, version: string) => AssetSpec | undefined;
+    getFunctionSpec?: (key: string, version: string) => JsonataFunctionSpec | undefined;
+}): ResourceDep[];