@formancy/server-core 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,4 @@
+formancy
+Copyright 2026 Daniel Bacher
+
+This product includes software developed by the formancy project.

package/README.md

@@ -0,0 +1,47 @@
+<!-- Part of formancy: https://github.com/sharkysan/formancy.ai -->
+
+# @formancy/server-core
+
+The formancy backend's use-cases, with no HTTP framework and no database driver
+in sight: publish, resolve, submit, drafts, listing, export, and the identity
+and authorization model.
+
+Everything talks to a `Storage` port. The same code runs over Postgres in
+`@formancy/server` and over a `Map` in tests, which is what makes these
+behaviours testable without a database and portable across ones.
+
+## Two load-bearing decisions
+
+**Submission is a replay, not a check.** `createSubmission` rebuilds the engine
+from the exact schema version the client says it rendered, runs it over the
+submitted data, and stores the *canonical* result: computed values are
+recomputed and overwrite whatever arrived, and fields the server evaluates as
+hidden are stripped. A client cannot smuggle data into a hidden branch by lying
+about what was shown. Client validation is UX; this is truth.
+
+**Nothing ambient.** Identity, time, hashing and randomness are injected. That
+is what lets a submission be replayed later and produce byte-identical computed
+values — and it is why the auth tests can use deterministic fakes while the real
+server gets argon2id and a CSPRNG.
+
+## Use
+
+```ts
+import { publishForm, createSubmission, can } from '@formancy/server-core'
+
+const published = await publishForm(deps, { path: 'contact-us', schema })
+// publishForm is the save gate: structural validation, then the engine's own
+// compile — a form that could loop is refused here and never persisted.
+
+const outcome = await createSubmission(deps, {
+  path: 'contact-us',
+  declaredSchemaHash: published.schemaHash,
+  data: payload,
+})
+```
+
+Authorization is one readable table (`can(actor, action)`), deliberately not
+Postgres row-level security: RLS couples the application to per-request database
+roles and hides authorization from the test suite.
+
+Docs: `apps/docs` (Quickstart: self-hosting).

package/dist/index.d.mts

@@ -0,0 +1,324 @@
+import { Change, FormSchema } from "@formancy/spec";
+import { SchemaError } from "@formancy/spec/validate";
+import { CapabilitySource } from "@formancy/core";
+//#region src/auth.d.ts
+/**
+ * The management plane's identity and authorization, framework-free.
+ *
+ * Hashing and randomness are injected — this package cannot reach a CSPRNG or
+ * argon2 on its own, the composition root hands them in — which keeps every
+ * behaviour here testable with deterministic fakes while the real server gets
+ * real cryptography.
+ */
+type Role = 'admin' | 'editor' | 'viewer';
+interface Actor {
+  kind: 'user' | 'apiKey';
+  id: string;
+  role: Role;
+}
+interface AuthDeps {
+  storage: Storage;
+  newId(): string;
+  nowIso(): string;
+  /** At least 160 bits of entropy, URL-safe. Injected, never Math.random. */
+  randomToken(): string;
+  hashSecret(secret: string): Promise<string>;
+  verifySecret(secret: string, hash: string): Promise<boolean>;
+}
+type CreateUserOutcome = {
+  ok: true;
+  id: string;
+} | {
+  ok: false;
+  message: string;
+};
+export declare function createLocalUser(deps: AuthDeps, input: {
+  email: string;
+  password: string;
+  role: Role;
+}): Promise<CreateUserOutcome>;
+type AuthOutcome = {
+  ok: true;
+  actor: Actor;
+} | {
+  ok: false;
+};
+/**
+ * A wrong password and an unknown email answer identically, and BOTH run a
+ * hash verification — the difference in shape or timing would be a
+ * user-enumeration oracle.
+ */
+export declare function authenticateLocal(deps: AuthDeps, input: {
+  email: string;
+  password: string;
+}): Promise<AuthOutcome>;
+type CreateApiKeyOutcome = {
+  ok: true;
+  id: string;
+  secret: string;
+} | {
+  ok: false;
+  message: string;
+};
+export declare function createApiKey(deps: AuthDeps, input: {
+  name: string;
+  role: Role;
+}): Promise<CreateApiKeyOutcome>;
+export declare function authenticateApiKey(deps: AuthDeps, presented: string): Promise<AuthOutcome>;
+/**
+ * The whole authorization model, in one table a reviewer can read top to
+ * bottom. Deliberately NOT Postgres RLS in this phase: RLS couples the app to
+ * per-request database roles and hides authorization from the test suite.
+ * An unknown action is denied — permissions are granted by presence, never by
+ * omission.
+ */
+type Action = 'form.read' | 'form.publish' | 'submission.read' | 'submission.export' | 'draft.write' | 'user.create' | 'apiKey.create';
+export declare function can(actor: Actor, action: Action): boolean;
+//#endregion
+//#region src/ports.d.ts
+/**
+ * The storage port. Implemented over Postgres in @formancy/server and over a
+ * Map in tests — the use-cases cannot tell the difference, which is what makes
+ * them testable without a database and portable across ones.
+ */
+interface FormRecord {
+  id: string;
+  path: string;
+  currentVersionId: string | null;
+}
+interface FormVersionRecord {
+  id: string;
+  formId: string;
+  version: number;
+  schema: FormSchema;
+  schemaHash: string;
+}
+interface SubmissionRecord {
+  id: string;
+  formId: string;
+  formVersionId: string;
+  data: unknown;
+  submittedAt: string;
+}
+interface UserRecord {
+  id: string;
+  email: string;
+  passwordHash: string;
+  role: Role;
+  createdAt: string;
+}
+interface ApiKeyRecord {
+  id: string;
+  name: string;
+  /** The visible first characters — index and display, never authentication. */
+  prefix: string;
+  secretHash: string;
+  role: Role;
+  createdAt: string;
+  revokedAt: string | null;
+}
+interface DraftRecord {
+  id: string;
+  formId: string;
+  formVersionId: string;
+  data: unknown;
+  updatedAt: string;
+}
+interface Storage {
+  getFormByPath(path: string): Promise<FormRecord | undefined>;
+  listForms(): Promise<FormRecord[]>;
+  createForm(record: FormRecord): Promise<void>;
+  setCurrentVersion(formId: string, versionId: string): Promise<void>;
+  insertVersion(record: FormVersionRecord): Promise<void>;
+  getVersionById(id: string): Promise<FormVersionRecord | undefined>;
+  findVersionByHash(formId: string, schemaHash: string): Promise<FormVersionRecord | undefined>;
+  latestVersionNumber(formId: string): Promise<number>;
+  insertSubmission(record: SubmissionRecord): Promise<void>;
+  listSubmissions(): Promise<SubmissionRecord[]>;
+  /** Newest first. */
+  listSubmissionsByForm(formId: string): Promise<SubmissionRecord[]>;
+  listVersionsByForm(formId: string): Promise<FormVersionRecord[]>;
+  upsertDraft(record: DraftRecord): Promise<void>;
+  getDraft(formId: string, draftId: string): Promise<DraftRecord | undefined>;
+  insertUser(record: UserRecord): Promise<void>;
+  getUserByEmail(email: string): Promise<UserRecord | undefined>;
+  insertApiKey(record: ApiKeyRecord): Promise<void>;
+  listApiKeys(): Promise<ApiKeyRecord[]>;
+  findApiKeysByPrefix(prefix: string): Promise<ApiKeyRecord[]>;
+  revokeApiKey(id: string, atIso: string): Promise<void>;
+}
+//#endregion
+//#region src/use-cases.d.ts
+/**
+ * The backend's use-cases, framework-free.
+ *
+ * Identity and time are injected like every other capability: the server pins
+ * one clock per request, so a submission can be replayed later and produce the
+ * same computed values byte for byte. Nothing here reads Date.now or crypto.
+ */
+interface ServerDeps {
+  storage: Storage;
+  newId(): string;
+  nowIso(): string;
+  /** The clock/randomness the ENGINE sees during replay. */
+  capabilities: CapabilitySource;
+}
+type PublishOutcome = {
+  ok: true;
+  formId: string;
+  versionId: string;
+  version: number;
+  schemaHash: string;
+} | {
+  ok: false;
+  kind: 'invalid_schema';
+  errors?: SchemaError[];
+} | {
+  ok: false;
+  kind: 'invalid_logic';
+  message: string;
+};
+/**
+ * Publish a schema as a form's next version.
+ *
+ * This is the save gate: structural validation, then the ENGINE's own compile
+ * — type-checked expressions, kind policies and the cycle graph — so a form
+ * that can loop or read a ghost field is refused here and never persisted.
+ * Republishing the identical document is idempotent, because "deploy again"
+ * must never manufacture a version.
+ */
+export declare function publishForm(deps: ServerDeps, input: {
+  path: string;
+  schema: unknown;
+}): Promise<PublishOutcome>;
+interface ResolvedForm {
+  formId: string;
+  versionId: string;
+  version: number;
+  schema: FormSchema;
+  schemaHash: string;
+}
+export declare function resolveForm(deps: ServerDeps, path: string): Promise<ResolvedForm | undefined>;
+type SubmissionOutcome = {
+  ok: true;
+  id: string;
+  canonicalData: unknown;
+} | {
+  ok: false;
+  kind: 'unknown_form';
+} | {
+  ok: false;
+  kind: 'version_changed';
+  current?: ResolvedForm;
+} | {
+  ok: false;
+  kind: 'invalid';
+  errors: Record<string, string[]>;
+};
+/**
+ * Accept one submission: resolve the version the client says it rendered,
+ * replay the engine over the submitted data, and store the CANONICAL result.
+ *
+ * The replay is the whole point. Computed values are recomputed and overwrite
+ * whatever arrived; visibility is evaluated server-side and hidden branches
+ * are stripped, so a client cannot smuggle data by lying about what was shown.
+ * Client validation is UX; this is truth.
+ */
+export declare function createSubmission(deps: ServerDeps, input: {
+  path: string;
+  declaredSchemaHash: string;
+  data: unknown;
+}): Promise<SubmissionOutcome>;
+interface ListedSubmission {
+  id: string;
+  version: number;
+  submittedAt: string;
+  data: unknown;
+}
+/** The submissions of one form, newest first, each tagged with the schema
+ *  version that produced it. Undefined for an unknown form: the caller must
+ *  404, and an empty list would lie about that. */
+export declare function listSubmissions(deps: ServerDeps, path: string): Promise<ListedSubmission[] | undefined>;
+/**
+ * Every submission of a form as CSV, columns UNIONED across schema versions:
+ * the current version's columns lead in its own order, and columns that only
+ * exist in older versions follow — data outlives the field that collected it,
+ * and an export that silently dropped extinct columns would lose it.
+ *
+ * A repeater is one column carrying its rows as JSON: rows-per-cell beats
+ * exploding one submission across several CSV lines, which breaks every
+ * spreadsheet join a business user will try.
+ */
+export declare function exportCsv(deps: ServerDeps, path: string): Promise<string | undefined>;
+/** Save (or re-save) a partial form, bound to the CURRENT version. Undefined
+ *  for an unknown form. */
+export declare function saveDraft(deps: ServerDeps, input: {
+  path: string;
+  draftId: string;
+  data: unknown;
+}): Promise<{
+  version: number;
+} | undefined>;
+interface DraftMigration {
+  severity: 'lossy';
+  changes: Change[];
+}
+type ResumeOutcome = {
+  outcome: 'resumed';
+  version: number;
+  schema: FormSchema;
+  schemaHash: string;
+  data: unknown;
+  /** Present when the rebind lost something; absent for a silent rebind. */
+  migration?: DraftMigration;
+} | {
+  /** The schema changed in a way no automatic rebind survives: the draft
+   *  comes back against ITS OWN version, and the caller offers a restart. */
+  outcome: 'readOnly';
+  version: number;
+  schema: FormSchema;
+  data: unknown;
+};
+/**
+ * Resume a draft — and migrate it LAZILY if the form was republished since,
+ * which is versioning rule five: never migrate eagerly on publish, because
+ * most drafts are abandoned and eager migration multiplies every publish by
+ * every draft.
+ *
+ * diffSchemas drives the decision: `compatible` rebinds silently, `lossy`
+ * rebinds with a report — declared renames carry their value to the new key,
+ * removed fields move their value into `__orphaned` rather than deleting it —
+ * and `breaking` refuses to rebind at all. A successful rebind is persisted,
+ * so the migration runs once, not on every resume.
+ */
+export declare function resumeDraft(deps: ServerDeps, input: {
+  path: string;
+  draftId: string;
+}): Promise<ResumeOutcome | undefined>;
+interface ListedForm {
+  path: string;
+  title: string;
+  version: number;
+  schemaHash: string;
+}
+/** Every form with its current version — the admin's landing view. */
+export declare function listForms(deps: ServerDeps): Promise<ListedForm[]>;
+interface ListedVersion {
+  version: number;
+  schemaHash: string;
+  title: string;
+}
+/** A form's version history, newest first — metadata only, because a history
+ *  view rendering fifty full schemas would be its own denial of service. */
+export declare function listVersions(deps: ServerDeps, path: string): Promise<ListedVersion[] | undefined>;
+//#endregion
+//#region src/testing/memory-storage.d.ts
+/**
+ * The in-memory Storage — the second implementation that keeps the port
+ * honest, and the one unit tests run against. Deliberately dumb: Maps and
+ * scans, no cleverness to accidentally diverge from SQL semantics.
+ */
+export declare function createMemoryStorage(): Storage;
+//#endregion
+export type { Action, Actor, AuthDeps, AuthOutcome, DraftMigration, DraftRecord, FormRecord, FormVersionRecord, ListedForm, ListedSubmission, ListedVersion, PublishOutcome, ResolvedForm, ResumeOutcome, Role, ServerDeps, Storage, SubmissionOutcome, SubmissionRecord };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/auth.ts","../src/ports.ts","../src/use-cases.ts","../src/testing/memory-storage.ts"],"mappings":";;;;;;;;;;;;KAUY;UAEK;EACf;EACA;EACA,MAAM;;UAGS;EACf,SAAS;EACT;EACA;;EAEA;EACA,WAAW,iBAAiB;EAC5B,aAAa,gBAAgB,eAAe;;KAKlC;EACN;EAAU;;EACV;EAAW;;wBAEK,gBACpB,MAAM,UACN;EAAS;EAAe;EAAkB,MAAM;IAC/C,QAAQ;KAmBC;EAAgB;EAAU,OAAO;;EAAY;;;;;;;wBAOnC,kBACpB,MAAM,UACN;EAAS;EAAe;IACvB,QAAQ;KAYC;EACN;EAAU;EAAY;;EACtB;EAAW;;wBAEK,aACpB,MAAM,UACN;EAAS;EAAc,MAAM;IAC5B,QAAQ;wBAmBW,mBAAmB,MAAM,UAAU,oBAAoB,QAAQ;;;;;;;;KAkBzE;wBAwBI,IAAI,OAAO,OAAO,QAAQ;;;;;;;;UC1IzB;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,QAAQ;EACR;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,MAAM;EACN;;UAGe;EACf;EACA;;EAEA;EACA;EACA,MAAM;EACN;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf,cAAc,eAAe,QAAQ;EACrC,aAAa,QAAQ;EACrB,WAAW,QAAQ,aAAa;EAChC,kBAAkB,gBAAgB,oBAAoB;EACtD,cAAc,QAAQ,oBAAoB;EAC1C,eAAe,aAAa,QAAQ;EACpC,kBAAkB,gBAAgB,qBAAqB,QAAQ;EAC/D,oBAAoB,iBAAiB;EACrC,iBAAiB,QAAQ,mBAAmB;EAC5C,mBAAmB,QAAQ;;EAE3B,sBAAsB,iBAAiB,QAAQ;EAC/C,mBAAmB,iBAAiB,QAAQ;EAC5C,YAAY,QAAQ,cAAc;EAClC,SAAS,gBAAgB,kBAAkB,QAAQ;EACnD,WAAW,QAAQ,aAAa;EAChC,eAAe,gBAAgB,QAAQ;EACvC,aAAa,QAAQ,eAAe;EACpC,eAAe,QAAQ;EACvB,oBAAoB,iBAAiB,QAAQ;EAC7C,aAAa,YAAY,gBAAgB;;;;;;;;;;;UC/D1B;EACf,SAAS;EACT;EACA;;EAEA,cAAc;;KAGJ;EACN;EAAU;EAAgB;EAAmB;EAAiB;;EAC9D;EAAW;EAAwB,SAAS;;EAC5C;EAAW;EAAuB;;;;;;;;;;;wBAWlB,YACpB,MAAM,YACN;EAAS;EAAc;IACtB,QAAQ;UAsDM;EACf;EACA;EACA;EACA,QAAQ;EACR;;wBAGoB,YAAY,MAAM,YAAY,eAAe,QAAQ;KAc/D;EACN;EAAU;EAAY;;EACtB;EAAW;;EACX;EAAW;EAAyB,UAAU;;EAC9C;EAAW;EAAiB,QAAQ;;;;;;;;;;;wBAWpB,iBACpB,MAAM,YACN;EAAS;EAAc;EAA4B;IAClD,QAAQ;UA6BM;EACf;EACA;EACA;EACA;;;;;wBAMoB,gBACpB,MAAM,YACN,eACC,QAAQ;;;;;;;;;;;wBA0BW,UAAU,MAAM,YAAY,eAAe;;;wBAwE3C,UACpB,MAAM,YACN;EAAS;EAAc;EAAiB;IACvC;EAAU;;UAcI;EACf;EACA,SAAS;;KAGC;EAEN;EACA;EACA,QAAQ;EACR;EACA;;EAEA,YAAY;;;;EAKZ;EACA;EACA,QAAQ;EACR;;;;;;;;;;;;;;wBAegB,YACpB,MAAM,YACN;EAAS;EAAc;IACtB,QAAQ;UA4HM;EACf;EACA;EACA;EACA;;;wBAIoB,UAAU,MAAM,aAAa,QAAQ;UAiB1C;EACf;EACA;EACA;;;;wBAKoB,aACpB,MAAM,YACN,eACC,QAAQ;;;;;;;;wBCneK,uBAAuB"}

package/dist/index.mjs

@@ -0,0 +1,546 @@
+import { diffSchemas, schemaHash } from "@formancy/spec";
+import { validateSchema } from "@formancy/spec/validate";
+import { createFormEngine } from "@formancy/core";
+//#region src/use-cases.ts
+/**
+* Publish a schema as a form's next version.
+*
+* This is the save gate: structural validation, then the ENGINE's own compile
+* — type-checked expressions, kind policies and the cycle graph — so a form
+* that can loop or read a ghost field is refused here and never persisted.
+* Republishing the identical document is idempotent, because "deploy again"
+* must never manufacture a version.
+*/
+async function publishForm(deps, input) {
+	const validated = validateSchema(input.schema);
+	if (!validated.valid) return {
+		ok: false,
+		kind: "invalid_schema",
+		errors: validated.errors
+	};
+	const schema = validated.schema;
+	try {
+		createFormEngine({
+			schema,
+			capabilities: deps.capabilities
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			kind: "invalid_logic",
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+	const hash = schemaHash(schema);
+	const existing = await deps.storage.getFormByPath(input.path);
+	if (existing !== void 0) {
+		const current = existing.currentVersionId === null ? void 0 : await deps.storage.getVersionById(existing.currentVersionId);
+		if (current !== void 0 && current.schemaHash === hash) return {
+			ok: true,
+			formId: existing.id,
+			versionId: current.id,
+			version: current.version,
+			schemaHash: hash
+		};
+		const version = await deps.storage.latestVersionNumber(existing.id) + 1;
+		const versionId = deps.newId();
+		await deps.storage.insertVersion({
+			id: versionId,
+			formId: existing.id,
+			version,
+			schema,
+			schemaHash: hash
+		});
+		await deps.storage.setCurrentVersion(existing.id, versionId);
+		return {
+			ok: true,
+			formId: existing.id,
+			versionId,
+			version,
+			schemaHash: hash
+		};
+	}
+	const formId = deps.newId();
+	const versionId = deps.newId();
+	await deps.storage.createForm({
+		id: formId,
+		path: input.path,
+		currentVersionId: null
+	});
+	await deps.storage.insertVersion({
+		id: versionId,
+		formId,
+		version: 1,
+		schema,
+		schemaHash: hash
+	});
+	await deps.storage.setCurrentVersion(formId, versionId);
+	return {
+		ok: true,
+		formId,
+		versionId,
+		version: 1,
+		schemaHash: hash
+	};
+}
+async function resolveForm(deps, path) {
+	const form = await deps.storage.getFormByPath(path);
+	if (form === void 0 || form.currentVersionId === null) return void 0;
+	const current = await deps.storage.getVersionById(form.currentVersionId);
+	if (current === void 0) return void 0;
+	return {
+		formId: form.id,
+		versionId: current.id,
+		version: current.version,
+		schema: current.schema,
+		schemaHash: current.schemaHash
+	};
+}
+/**
+* Accept one submission: resolve the version the client says it rendered,
+* replay the engine over the submitted data, and store the CANONICAL result.
+*
+* The replay is the whole point. Computed values are recomputed and overwrite
+* whatever arrived; visibility is evaluated server-side and hidden branches
+* are stripped, so a client cannot smuggle data by lying about what was shown.
+* Client validation is UX; this is truth.
+*/
+async function createSubmission(deps, input) {
+	const current = await resolveForm(deps, input.path);
+	if (current === void 0) return {
+		ok: false,
+		kind: "unknown_form"
+	};
+	if (input.declaredSchemaHash !== current.schemaHash) return {
+		ok: false,
+		kind: "version_changed",
+		current
+	};
+	const engine = createFormEngine({
+		schema: current.schema,
+		initialValue: input.data,
+		capabilities: deps.capabilities
+	});
+	const outcome = engine.submit();
+	if (!outcome.ok) return {
+		ok: false,
+		kind: "invalid",
+		errors: outcome.errors
+	};
+	const id = deps.newId();
+	await deps.storage.insertSubmission({
+		id,
+		formId: current.formId,
+		formVersionId: current.versionId,
+		data: engine.value(),
+		submittedAt: deps.nowIso()
+	});
+	return {
+		ok: true,
+		id,
+		canonicalData: engine.value()
+	};
+}
+/** The submissions of one form, newest first, each tagged with the schema
+*  version that produced it. Undefined for an unknown form: the caller must
+*  404, and an empty list would lie about that. */
+async function listSubmissions(deps, path) {
+	const form = await deps.storage.getFormByPath(path);
+	if (form === void 0) return void 0;
+	const versions = await deps.storage.listVersionsByForm(form.id);
+	const versionNumberById = new Map(versions.map((version) => [version.id, version.version]));
+	return (await deps.storage.listSubmissionsByForm(form.id)).map((record) => ({
+		id: record.id,
+		version: versionNumberById.get(record.formVersionId) ?? 0,
+		submittedAt: record.submittedAt,
+		data: record.data
+	}));
+}
+/**
+* Every submission of a form as CSV, columns UNIONED across schema versions:
+* the current version's columns lead in its own order, and columns that only
+* exist in older versions follow — data outlives the field that collected it,
+* and an export that silently dropped extinct columns would lose it.
+*
+* A repeater is one column carrying its rows as JSON: rows-per-cell beats
+* exploding one submission across several CSV lines, which breaks every
+* spreadsheet join a business user will try.
+*/
+async function exportCsv(deps, path) {
+	const form = await deps.storage.getFormByPath(path);
+	if (form === void 0) return void 0;
+	const versions = await deps.storage.listVersionsByForm(form.id);
+	const versionNumberById = new Map(versions.map((version) => [version.id, version.version]));
+	const columns = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const version of versions) for (const column of dataColumns(version.schema)) if (!seen.has(column)) {
+		seen.add(column);
+		columns.push(column);
+	}
+	const records = await deps.storage.listSubmissionsByForm(form.id);
+	const lines = [[
+		"id",
+		"submittedAt",
+		"version",
+		...columns
+	].map(csvCell).join(",")];
+	for (const record of records) {
+		const cells = [
+			record.id,
+			record.submittedAt,
+			String(versionNumberById.get(record.formVersionId) ?? 0),
+			...columns.map((column) => cellValue(record.data, column))
+		];
+		lines.push(cells.map(csvCell).join(","));
+	}
+	return lines.join("\n") + "\n";
+}
+/** One column per collected answer: leaves as dotted paths through groups,
+*  a repeater as a single column, pages transparent as always. */
+function dataColumns(schema) {
+	const columns = [];
+	const walk = (fields, prefix) => {
+		for (const field of fields) if (field.type === "page") walk(field.fields ?? [], prefix);
+		else if (field.type === "group") walk(field.fields ?? [], `${prefix}${field.key}.`);
+		else columns.push(`${prefix}${field.key}`);
+	};
+	walk(schema.model.fields, "");
+	return columns;
+}
+function cellValue(data, column) {
+	let current = data;
+	for (const segment of column.split(".")) {
+		if (current === null || typeof current !== "object") return "";
+		current = current[segment];
+	}
+	if (current === void 0 || current === null) return "";
+	if (typeof current === "object") return JSON.stringify(current);
+	if (typeof current === "string" && FORMULA_STARTERS.has(current.charAt(0))) return "'" + current;
+	return String(current);
+}
+function csvCell(value) {
+	return /[",\n\r]/.test(value) ? `"${value.replaceAll("\"", "\"\"")}"` : value;
+}
+/** Save (or re-save) a partial form, bound to the CURRENT version. Undefined
+*  for an unknown form. */
+async function saveDraft(deps, input) {
+	const current = await resolveForm(deps, input.path);
+	if (current === void 0) return void 0;
+	await deps.storage.upsertDraft({
+		id: input.draftId,
+		formId: current.formId,
+		formVersionId: current.versionId,
+		data: input.data,
+		updatedAt: deps.nowIso()
+	});
+	return { version: current.version };
+}
+/**
+* Resume a draft — and migrate it LAZILY if the form was republished since,
+* which is versioning rule five: never migrate eagerly on publish, because
+* most drafts are abandoned and eager migration multiplies every publish by
+* every draft.
+*
+* diffSchemas drives the decision: `compatible` rebinds silently, `lossy`
+* rebinds with a report — declared renames carry their value to the new key,
+* removed fields move their value into `__orphaned` rather than deleting it —
+* and `breaking` refuses to rebind at all. A successful rebind is persisted,
+* so the migration runs once, not on every resume.
+*/
+async function resumeDraft(deps, input) {
+	const current = await resolveForm(deps, input.path);
+	if (current === void 0) return void 0;
+	const draft = await deps.storage.getDraft(current.formId, input.draftId);
+	if (draft === void 0) return void 0;
+	if (draft.formVersionId === current.versionId) return {
+		outcome: "resumed",
+		version: current.version,
+		schema: current.schema,
+		schemaHash: current.schemaHash,
+		data: draft.data
+	};
+	const draftVersion = await deps.storage.getVersionById(draft.formVersionId);
+	if (draftVersion === void 0) return void 0;
+	const changes = diffSchemas(draftVersion.schema, current.schema);
+	const severity = changes.reduce((worst, change) => SEVERITY_RANK[change.severity] > SEVERITY_RANK[worst] ? change.severity : worst, "compatible");
+	if (severity === "breaking") return {
+		outcome: "readOnly",
+		version: draftVersion.version,
+		schema: draftVersion.schema,
+		data: draft.data
+	};
+	const migrated = migrateDraftData(draft.data, current.schema, changes);
+	await deps.storage.upsertDraft({
+		id: draft.id,
+		formId: draft.formId,
+		formVersionId: current.versionId,
+		data: migrated,
+		updatedAt: deps.nowIso()
+	});
+	return {
+		outcome: "resumed",
+		version: current.version,
+		schema: current.schema,
+		schemaHash: current.schemaHash,
+		data: migrated,
+		...severity === "lossy" ? { migration: {
+			severity,
+			changes
+		} } : {}
+	};
+}
+const SEVERITY_RANK = {
+	compatible: 0,
+	lossy: 1,
+	breaking: 2
+};
+const FORMULA_STARTERS = /* @__PURE__ */ new Set([
+	"=",
+	"+",
+	"-",
+	"@",
+	String.fromCharCode(9),
+	String.fromCharCode(13)
+]);
+function migrateDraftData(data, currentSchema, changes) {
+	if (data === null || typeof data !== "object" || Array.isArray(data)) return data;
+	const migrated = structuredCloneJson(data);
+	applyRenames(currentSchema.model.fields, migrated);
+	const orphaned = {};
+	for (const change of changes) {
+		if (change.kind !== "field.removed") continue;
+		const dataPath = change.path.replace(/^model\.fields\./, "");
+		if (dataPath.includes("[]")) continue;
+		const value = takeAtDottedPath(migrated, dataPath);
+		if (value !== void 0) orphaned[dataPath] = value;
+	}
+	if (Object.keys(orphaned).length > 0) migrated["__orphaned"] = {
+		...migrated["__orphaned"],
+		...orphaned
+	};
+	return migrated;
+}
+function applyRenames(fields, data) {
+	for (const field of fields) {
+		if (field.type === "page") {
+			applyRenames(field.fields ?? [], data);
+			continue;
+		}
+		if (field.renamedFrom !== void 0 && !(field.key in data) && field.renamedFrom in data) {
+			data[field.key] = data[field.renamedFrom];
+			delete data[field.renamedFrom];
+		}
+		if (field.type === "group" && typeof data[field.key] === "object" && data[field.key] !== null) applyRenames(field.fields ?? [], data[field.key]);
+	}
+}
+/** Remove and return the value at a dotted path, pruning nothing else. */
+function takeAtDottedPath(data, dottedPath) {
+	const segments = dottedPath.split(".");
+	let parent = data;
+	for (const segment of segments.slice(0, -1)) {
+		const next = parent[segment];
+		if (next === null || typeof next !== "object" || Array.isArray(next)) return void 0;
+		parent = next;
+	}
+	const last = segments[segments.length - 1];
+	const value = parent[last];
+	delete parent[last];
+	return value;
+}
+/** JSON-safe deep clone: draft data is JSON by construction, and this package
+*  runs without structuredClone in its lib on purpose. */
+function structuredCloneJson(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+/** Every form with its current version — the admin's landing view. */
+async function listForms(deps) {
+	const forms = await deps.storage.listForms();
+	const listed = [];
+	for (const form of forms) {
+		if (form.currentVersionId === null) continue;
+		const current = await deps.storage.getVersionById(form.currentVersionId);
+		if (current === void 0) continue;
+		listed.push({
+			path: form.path,
+			title: current.schema.title,
+			version: current.version,
+			schemaHash: current.schemaHash
+		});
+	}
+	return listed;
+}
+/** A form's version history, newest first — metadata only, because a history
+*  view rendering fifty full schemas would be its own denial of service. */
+async function listVersions(deps, path) {
+	const form = await deps.storage.getFormByPath(path);
+	if (form === void 0) return void 0;
+	return (await deps.storage.listVersionsByForm(form.id)).map((version) => ({
+		version: version.version,
+		schemaHash: version.schemaHash,
+		title: version.schema.title
+	}));
+}
+//#endregion
+//#region src/testing/memory-storage.ts
+/**
+* The in-memory Storage — the second implementation that keeps the port
+* honest, and the one unit tests run against. Deliberately dumb: Maps and
+* scans, no cleverness to accidentally diverge from SQL semantics.
+*/
+function createMemoryStorage() {
+	const forms = /* @__PURE__ */ new Map();
+	const versions = /* @__PURE__ */ new Map();
+	const submissions = [];
+	const drafts = /* @__PURE__ */ new Map();
+	const users = /* @__PURE__ */ new Map();
+	const apiKeys = /* @__PURE__ */ new Map();
+	return {
+		getFormByPath: async (path) => [...forms.values()].find((form) => form.path === path),
+		listForms: async () => [...forms.values()].map((form) => ({ ...form })),
+		createForm: async (record) => {
+			forms.set(record.id, { ...record });
+		},
+		setCurrentVersion: async (formId, versionId) => {
+			const form = forms.get(formId);
+			if (form === void 0) throw new Error(`No form "${formId}"`);
+			form.currentVersionId = versionId;
+		},
+		insertVersion: async (record) => {
+			versions.set(record.id, { ...record });
+		},
+		getVersionById: async (id) => versions.get(id),
+		findVersionByHash: async (formId, hash) => [...versions.values()].find((version) => version.formId === formId && version.schemaHash === hash),
+		latestVersionNumber: async (formId) => Math.max(0, ...[...versions.values()].filter((version) => version.formId === formId).map((version) => version.version)),
+		insertSubmission: async (record) => {
+			submissions.push({ ...record });
+		},
+		listSubmissions: async () => [...submissions],
+		listSubmissionsByForm: async (formId) => submissions.filter((record) => record.formId === formId).reverse(),
+		listVersionsByForm: async (formId) => [...versions.values()].filter((version) => version.formId === formId).sort((a, b) => b.version - a.version),
+		upsertDraft: async (record) => {
+			drafts.set(record.formId + ":" + record.id, { ...record });
+		},
+		getDraft: async (formId, draftId) => drafts.get(formId + ":" + draftId),
+		insertUser: async (record) => {
+			users.set(record.id, { ...record });
+		},
+		getUserByEmail: async (email) => [...users.values()].find((user) => user.email === email),
+		insertApiKey: async (record) => {
+			apiKeys.set(record.id, { ...record });
+		},
+		listApiKeys: async () => [...apiKeys.values()].map((key) => ({ ...key })),
+		findApiKeysByPrefix: async (prefix) => [...apiKeys.values()].filter((key) => key.prefix === prefix),
+		revokeApiKey: async (id, atIso) => {
+			const key = apiKeys.get(id);
+			if (key !== void 0) key.revokedAt = atIso;
+		}
+	};
+}
+//#endregion
+//#region src/auth.ts
+const MIN_PASSWORD_LENGTH = 10;
+async function createLocalUser(deps, input) {
+	if (input.password.length < MIN_PASSWORD_LENGTH) return {
+		ok: false,
+		message: `A password needs at least ${MIN_PASSWORD_LENGTH} characters.`
+	};
+	if (await deps.storage.getUserByEmail(input.email) !== void 0) return {
+		ok: false,
+		message: "That email is already in use."
+	};
+	const id = deps.newId();
+	await deps.storage.insertUser({
+		id,
+		email: input.email,
+		passwordHash: await deps.hashSecret(input.password),
+		role: input.role,
+		createdAt: deps.nowIso()
+	});
+	return {
+		ok: true,
+		id
+	};
+}
+/**
+* A wrong password and an unknown email answer identically, and BOTH run a
+* hash verification — the difference in shape or timing would be a
+* user-enumeration oracle.
+*/
+async function authenticateLocal(deps, input) {
+	const user = await deps.storage.getUserByEmail(input.email);
+	const hash = user?.passwordHash ?? await deps.hashSecret(`decoy:${deps.newId()}`);
+	const verified = await deps.verifySecret(input.password, hash);
+	if (user === void 0 || !verified) return { ok: false };
+	return {
+		ok: true,
+		actor: {
+			kind: "user",
+			id: user.id,
+			role: user.role
+		}
+	};
+}
+/** The visible prefix of an API key: enough to index and to name in a UI
+*  ("fmc_tok_a2c…"), never enough to authenticate. */
+const KEY_PREFIX_LENGTH = 12;
+async function createApiKey(deps, input) {
+	if (input.name.trim() === "") return {
+		ok: false,
+		message: "An API key needs a name."
+	};
+	const secret = `fmc_${deps.randomToken()}`;
+	const id = deps.newId();
+	await deps.storage.insertApiKey({
+		id,
+		name: input.name,
+		prefix: secret.slice(0, KEY_PREFIX_LENGTH),
+		secretHash: await deps.hashSecret(secret),
+		role: input.role,
+		createdAt: deps.nowIso(),
+		revokedAt: null
+	});
+	return {
+		ok: true,
+		id,
+		secret
+	};
+}
+async function authenticateApiKey(deps, presented) {
+	const candidates = await deps.storage.findApiKeysByPrefix(presented.slice(0, KEY_PREFIX_LENGTH));
+	for (const candidate of candidates) {
+		if (candidate.revokedAt !== null) continue;
+		if (await deps.verifySecret(presented, candidate.secretHash)) return {
+			ok: true,
+			actor: {
+				kind: "apiKey",
+				id: candidate.id,
+				role: candidate.role
+			}
+		};
+	}
+	return { ok: false };
+}
+const VIEWER_ACTIONS = ["form.read", "submission.read"];
+const EDITOR_ACTIONS = [
+	...VIEWER_ACTIONS,
+	"form.publish",
+	"submission.export",
+	"draft.write"
+];
+const ADMIN_ACTIONS = [
+	...EDITOR_ACTIONS,
+	"user.create",
+	"apiKey.create"
+];
+const PERMISSIONS = {
+	viewer: new Set(VIEWER_ACTIONS),
+	editor: new Set(EDITOR_ACTIONS),
+	admin: new Set(ADMIN_ACTIONS)
+};
+function can(actor, action) {
+	return PERMISSIONS[actor.role].has(action);
+}
+//#endregion
+export { authenticateApiKey, authenticateLocal, can, createApiKey, createLocalUser, createMemoryStorage, createSubmission, exportCsv, listForms, listSubmissions, listVersions, publishForm, resolveForm, resumeDraft, saveDraft };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/use-cases.ts","../src/testing/memory-storage.ts","../src/auth.ts"],"sourcesContent":["import { diffSchemas, schemaHash } from '@formancy/spec'\nimport type { Change, FormSchema } from '@formancy/spec'\nimport { validateSchema } from '@formancy/spec/validate'\nimport type { SchemaError } from '@formancy/spec/validate'\nimport { createFormEngine } from '@formancy/core'\nimport type { CapabilitySource } from '@formancy/core'\nimport type { Storage } from './ports.js'\n\n/**\n * The backend's use-cases, framework-free.\n *\n * Identity and time are injected like every other capability: the server pins\n * one clock per request, so a submission can be replayed later and produce the\n * same computed values byte for byte. Nothing here reads Date.now or crypto.\n */\nexport interface ServerDeps {\n  storage: Storage\n  newId(): string\n  nowIso(): string\n  /** The clock/randomness the ENGINE sees during replay. */\n  capabilities: CapabilitySource\n}\n\nexport type PublishOutcome =\n  | { ok: true; formId: string; versionId: string; version: number; schemaHash: string }\n  | { ok: false; kind: 'invalid_schema'; errors?: SchemaError[] }\n  | { ok: false; kind: 'invalid_logic'; message: string }\n\n/**\n * Publish a schema as a form's next version.\n *\n * This is the save gate: structural validation, then the ENGINE's own compile\n * — type-checked expressions, kind policies and the cycle graph — so a form\n * that can loop or read a ghost field is refused here and never persisted.\n * Republishing the identical document is idempotent, because \"deploy again\"\n * must never manufacture a version.\n */\nexport async function publishForm(\n  deps: ServerDeps,\n  input: { path: string; schema: unknown },\n): Promise<PublishOutcome> {\n  const validated = validateSchema(input.schema)\n  if (!validated.valid) return { ok: false, kind: 'invalid_schema', errors: validated.errors }\n  const schema: FormSchema = validated.schema\n\n  try {\n    createFormEngine({ schema, capabilities: deps.capabilities })\n  } catch (error) {\n    return {\n      ok: false,\n      kind: 'invalid_logic',\n      message: error instanceof Error ? error.message : String(error),\n    }\n  }\n\n  const hash = schemaHash(schema)\n  const existing = await deps.storage.getFormByPath(input.path)\n\n  if (existing !== undefined) {\n    const current =\n      existing.currentVersionId === null\n        ? undefined\n        : await deps.storage.getVersionById(existing.currentVersionId)\n    if (current !== undefined && current.schemaHash === hash) {\n      return {\n        ok: true,\n        formId: existing.id,\n        versionId: current.id,\n        version: current.version,\n        schemaHash: hash,\n      }\n    }\n\n    const version = (await deps.storage.latestVersionNumber(existing.id)) + 1\n    const versionId = deps.newId()\n    await deps.storage.insertVersion({\n      id: versionId,\n      formId: existing.id,\n      version,\n      schema,\n      schemaHash: hash,\n    })\n    await deps.storage.setCurrentVersion(existing.id, versionId)\n    return { ok: true, formId: existing.id, versionId, version, schemaHash: hash }\n  }\n\n  const formId = deps.newId()\n  const versionId = deps.newId()\n  await deps.storage.createForm({ id: formId, path: input.path, currentVersionId: null })\n  await deps.storage.insertVersion({ id: versionId, formId, version: 1, schema, schemaHash: hash })\n  await deps.storage.setCurrentVersion(formId, versionId)\n  return { ok: true, formId, versionId, version: 1, schemaHash: hash }\n}\n\nexport interface ResolvedForm {\n  formId: string\n  versionId: string\n  version: number\n  schema: FormSchema\n  schemaHash: string\n}\n\nexport async function resolveForm(deps: ServerDeps, path: string): Promise<ResolvedForm | undefined> {\n  const form = await deps.storage.getFormByPath(path)\n  if (form === undefined || form.currentVersionId === null) return undefined\n  const current = await deps.storage.getVersionById(form.currentVersionId)\n  if (current === undefined) return undefined\n  return {\n    formId: form.id,\n    versionId: current.id,\n    version: current.version,\n    schema: current.schema,\n    schemaHash: current.schemaHash,\n  }\n}\n\nexport type SubmissionOutcome =\n  | { ok: true; id: string; canonicalData: unknown }\n  | { ok: false; kind: 'unknown_form' }\n  | { ok: false; kind: 'version_changed'; current?: ResolvedForm }\n  | { ok: false; kind: 'invalid'; errors: Record<string, string[]> }\n\n/**\n * Accept one submission: resolve the version the client says it rendered,\n * replay the engine over the submitted data, and store the CANONICAL result.\n *\n * The replay is the whole point. Computed values are recomputed and overwrite\n * whatever arrived; visibility is evaluated server-side and hidden branches\n * are stripped, so a client cannot smuggle data by lying about what was shown.\n * Client validation is UX; this is truth.\n */\nexport async function createSubmission(\n  deps: ServerDeps,\n  input: { path: string; declaredSchemaHash: string; data: unknown },\n): Promise<SubmissionOutcome> {\n  const current = await resolveForm(deps, input.path)\n  if (current === undefined) return { ok: false, kind: 'unknown_form' }\n\n  if (input.declaredSchemaHash !== current.schemaHash) {\n    // The thin slice's staleVersionPolicy is `reject`: the acceptCompatible\n    // policy arrives with draft migration, driven by diffSchemas severity.\n    return { ok: false, kind: 'version_changed', current }\n  }\n\n  const engine = createFormEngine({\n    schema: current.schema,\n    initialValue: input.data,\n    capabilities: deps.capabilities,\n  })\n  const outcome = engine.submit()\n  if (!outcome.ok) return { ok: false, kind: 'invalid', errors: outcome.errors }\n\n  const id = deps.newId()\n  await deps.storage.insertSubmission({\n    id,\n    formId: current.formId,\n    formVersionId: current.versionId,\n    data: engine.value(),\n    submittedAt: deps.nowIso(),\n  })\n  return { ok: true, id, canonicalData: engine.value() }\n}\n\nexport interface ListedSubmission {\n  id: string\n  version: number\n  submittedAt: string\n  data: unknown\n}\n\n/** The submissions of one form, newest first, each tagged with the schema\n *  version that produced it. Undefined for an unknown form: the caller must\n *  404, and an empty list would lie about that. */\nexport async function listSubmissions(\n  deps: ServerDeps,\n  path: string,\n): Promise<ListedSubmission[] | undefined> {\n  const form = await deps.storage.getFormByPath(path)\n  if (form === undefined) return undefined\n\n  const versions = await deps.storage.listVersionsByForm(form.id)\n  const versionNumberById = new Map(versions.map((version) => [version.id, version.version]))\n\n  const records = await deps.storage.listSubmissionsByForm(form.id)\n  return records.map((record) => ({\n    id: record.id,\n    version: versionNumberById.get(record.formVersionId) ?? 0,\n    submittedAt: record.submittedAt,\n    data: record.data,\n  }))\n}\n\n/**\n * Every submission of a form as CSV, columns UNIONED across schema versions:\n * the current version's columns lead in its own order, and columns that only\n * exist in older versions follow — data outlives the field that collected it,\n * and an export that silently dropped extinct columns would lose it.\n *\n * A repeater is one column carrying its rows as JSON: rows-per-cell beats\n * exploding one submission across several CSV lines, which breaks every\n * spreadsheet join a business user will try.\n */\nexport async function exportCsv(deps: ServerDeps, path: string): Promise<string | undefined> {\n  const form = await deps.storage.getFormByPath(path)\n  if (form === undefined) return undefined\n\n  const versions = await deps.storage.listVersionsByForm(form.id)\n  const versionNumberById = new Map(versions.map((version) => [version.id, version.version]))\n\n  const columns: string[] = []\n  const seen = new Set<string>()\n  for (const version of versions) {\n    for (const column of dataColumns(version.schema)) {\n      if (!seen.has(column)) {\n        seen.add(column)\n        columns.push(column)\n      }\n    }\n  }\n\n  const records = await deps.storage.listSubmissionsByForm(form.id)\n  const lines = [['id', 'submittedAt', 'version', ...columns].map(csvCell).join(',')]\n  for (const record of records) {\n    const cells = [\n      record.id,\n      record.submittedAt,\n      String(versionNumberById.get(record.formVersionId) ?? 0),\n      ...columns.map((column) => cellValue(record.data, column)),\n    ]\n    lines.push(cells.map(csvCell).join(','))\n  }\n  return lines.join('\\n') + '\\n'\n}\n\n/** One column per collected answer: leaves as dotted paths through groups,\n *  a repeater as a single column, pages transparent as always. */\nfunction dataColumns(schema: FormSchema): string[] {\n  const columns: string[] = []\n  const walk = (fields: readonly FormSchema['model']['fields'][number][], prefix: string): void => {\n    for (const field of fields) {\n      if (field.type === 'page') walk(field.fields ?? [], prefix)\n      else if (field.type === 'group') walk(field.fields ?? [], `${prefix}${field.key}.`)\n      else columns.push(`${prefix}${field.key}`)\n    }\n  }\n  walk(schema.model.fields, '')\n  return columns\n}\n\nfunction cellValue(data: unknown, column: string): string {\n  let current: unknown = data\n  for (const segment of column.split('.')) {\n    if (current === null || typeof current !== 'object') return ''\n    current = (current as Record<string, unknown>)[segment]\n  }\n  if (current === undefined || current === null) return ''\n  if (typeof current === 'object') return JSON.stringify(current)\n  if (typeof current === 'string' && FORMULA_STARTERS.has(current.charAt(0))) {\n    // Spreadsheets execute a cell that starts like a formula. A submission is\n    // attacker-controlled and this file is opened by exactly the person worth\n    // attacking, so neutralise with the apostrophe convention. Only strings:\n    // a number cannot smuggle a formula, and a quoted -5 would break every\n    // numeric column.\n    return \"'\" + current\n  }\n  return String(current)\n}\n\nfunction csvCell(value: string): string {\n  return /[\",\\n\\r]/.test(value) ? `\"${value.replaceAll('\"', '\"\"')}\"` : value\n}\n\n/** Save (or re-save) a partial form, bound to the CURRENT version. Undefined\n *  for an unknown form. */\nexport async function saveDraft(\n  deps: ServerDeps,\n  input: { path: string; draftId: string; data: unknown },\n): Promise<{ version: number } | undefined> {\n  const current = await resolveForm(deps, input.path)\n  if (current === undefined) return undefined\n\n  await deps.storage.upsertDraft({\n    id: input.draftId,\n    formId: current.formId,\n    formVersionId: current.versionId,\n    data: input.data,\n    updatedAt: deps.nowIso(),\n  })\n  return { version: current.version }\n}\n\nexport interface DraftMigration {\n  severity: 'lossy'\n  changes: Change[]\n}\n\nexport type ResumeOutcome =\n  | {\n      outcome: 'resumed'\n      version: number\n      schema: FormSchema\n      schemaHash: string\n      data: unknown\n      /** Present when the rebind lost something; absent for a silent rebind. */\n      migration?: DraftMigration\n    }\n  | {\n      /** The schema changed in a way no automatic rebind survives: the draft\n       *  comes back against ITS OWN version, and the caller offers a restart. */\n      outcome: 'readOnly'\n      version: number\n      schema: FormSchema\n      data: unknown\n    }\n\n/**\n * Resume a draft — and migrate it LAZILY if the form was republished since,\n * which is versioning rule five: never migrate eagerly on publish, because\n * most drafts are abandoned and eager migration multiplies every publish by\n * every draft.\n *\n * diffSchemas drives the decision: `compatible` rebinds silently, `lossy`\n * rebinds with a report — declared renames carry their value to the new key,\n * removed fields move their value into `__orphaned` rather than deleting it —\n * and `breaking` refuses to rebind at all. A successful rebind is persisted,\n * so the migration runs once, not on every resume.\n */\nexport async function resumeDraft(\n  deps: ServerDeps,\n  input: { path: string; draftId: string },\n): Promise<ResumeOutcome | undefined> {\n  const current = await resolveForm(deps, input.path)\n  if (current === undefined) return undefined\n\n  const draft = await deps.storage.getDraft(current.formId, input.draftId)\n  if (draft === undefined) return undefined\n\n  if (draft.formVersionId === current.versionId) {\n    return {\n      outcome: 'resumed',\n      version: current.version,\n      schema: current.schema,\n      schemaHash: current.schemaHash,\n      data: draft.data,\n    }\n  }\n\n  const draftVersion = await deps.storage.getVersionById(draft.formVersionId)\n  if (draftVersion === undefined) return undefined\n\n  const changes = diffSchemas(draftVersion.schema, current.schema)\n  const severity = changes.reduce<'compatible' | 'lossy' | 'breaking'>(\n    (worst, change) =>\n      SEVERITY_RANK[change.severity] > SEVERITY_RANK[worst] ? change.severity : worst,\n    'compatible',\n  )\n\n  if (severity === 'breaking') {\n    return {\n      outcome: 'readOnly',\n      version: draftVersion.version,\n      schema: draftVersion.schema,\n      data: draft.data,\n    }\n  }\n\n  const migrated = migrateDraftData(draft.data, current.schema, changes)\n\n  await deps.storage.upsertDraft({\n    id: draft.id,\n    formId: draft.formId,\n    formVersionId: current.versionId,\n    data: migrated,\n    updatedAt: deps.nowIso(),\n  })\n\n  return {\n    outcome: 'resumed',\n    version: current.version,\n    schema: current.schema,\n    schemaHash: current.schemaHash,\n    data: migrated,\n    ...(severity === 'lossy' ? { migration: { severity, changes } } : {}),\n  }\n}\n\nconst SEVERITY_RANK = { compatible: 0, lossy: 1, breaking: 2 } as const\n\nconst FORMULA_STARTERS = new Set(['=', '+', '-', '@', String.fromCharCode(9), String.fromCharCode(13)])\n\nfunction migrateDraftData(data: unknown, currentSchema: FormSchema, changes: Change[]): unknown {\n  if (data === null || typeof data !== 'object' || Array.isArray(data)) return data\n  const migrated: Record<string, unknown> = structuredCloneJson(data as Record<string, unknown>)\n\n  // Declared renames first: the value follows the field to its new key.\n  applyRenames(currentSchema.model.fields, migrated)\n\n  // Then removals: the value moves aside instead of vanishing. Only top-level\n  // and group paths move; row members stay inside their (possibly orphaned)\n  // repeater value, which travels as a whole.\n  const orphaned: Record<string, unknown> = {}\n  for (const change of changes) {\n    if (change.kind !== 'field.removed') continue\n    const dataPath = change.path.replace(/^model\\.fields\\./, '')\n    if (dataPath.includes('[]')) continue\n    const value = takeAtDottedPath(migrated, dataPath)\n    if (value !== undefined) orphaned[dataPath] = value\n  }\n  if (Object.keys(orphaned).length > 0) {\n    migrated['__orphaned'] = {\n      ...(migrated['__orphaned'] as Record<string, unknown> | undefined),\n      ...orphaned,\n    }\n  }\n  return migrated\n}\n\nfunction applyRenames(fields: FormSchema['model']['fields'], data: Record<string, unknown>): void {\n  for (const field of fields) {\n    if (field.type === 'page') {\n      applyRenames(field.fields ?? [], data)\n      continue\n    }\n    if (field.renamedFrom !== undefined && !(field.key in data) && field.renamedFrom in data) {\n      data[field.key] = data[field.renamedFrom]\n      delete data[field.renamedFrom]\n    }\n    if (field.type === 'group' && typeof data[field.key] === 'object' && data[field.key] !== null) {\n      applyRenames(field.fields ?? [], data[field.key] as Record<string, unknown>)\n    }\n  }\n}\n\n/** Remove and return the value at a dotted path, pruning nothing else. */\nfunction takeAtDottedPath(data: Record<string, unknown>, dottedPath: string): unknown {\n  const segments = dottedPath.split('.')\n  let parent: Record<string, unknown> = data\n  for (const segment of segments.slice(0, -1)) {\n    const next = parent[segment]\n    if (next === null || typeof next !== 'object' || Array.isArray(next)) return undefined\n    parent = next as Record<string, unknown>\n  }\n  const last = segments[segments.length - 1]!\n  const value = parent[last]\n  delete parent[last]\n  return value\n}\n\n/** JSON-safe deep clone: draft data is JSON by construction, and this package\n *  runs without structuredClone in its lib on purpose. */\nfunction structuredCloneJson<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value)) as T\n}\n\nexport interface ListedForm {\n  path: string\n  title: string\n  version: number\n  schemaHash: string\n}\n\n/** Every form with its current version — the admin's landing view. */\nexport async function listForms(deps: ServerDeps): Promise<ListedForm[]> {\n  const forms = await deps.storage.listForms()\n  const listed: ListedForm[] = []\n  for (const form of forms) {\n    if (form.currentVersionId === null) continue\n    const current = await deps.storage.getVersionById(form.currentVersionId)\n    if (current === undefined) continue\n    listed.push({\n      path: form.path,\n      title: current.schema.title,\n      version: current.version,\n      schemaHash: current.schemaHash,\n    })\n  }\n  return listed\n}\n\nexport interface ListedVersion {\n  version: number\n  schemaHash: string\n  title: string\n}\n\n/** A form's version history, newest first — metadata only, because a history\n *  view rendering fifty full schemas would be its own denial of service. */\nexport async function listVersions(\n  deps: ServerDeps,\n  path: string,\n): Promise<ListedVersion[] | undefined> {\n  const form = await deps.storage.getFormByPath(path)\n  if (form === undefined) return undefined\n  const versions = await deps.storage.listVersionsByForm(form.id)\n  return versions.map((version) => ({\n    version: version.version,\n    schemaHash: version.schemaHash,\n    title: version.schema.title,\n  }))\n}\n","import type { ApiKeyRecord, DraftRecord, FormRecord, FormVersionRecord, Storage, SubmissionRecord, UserRecord } from '../ports.js'\n\n/**\n * The in-memory Storage — the second implementation that keeps the port\n * honest, and the one unit tests run against. Deliberately dumb: Maps and\n * scans, no cleverness to accidentally diverge from SQL semantics.\n */\nexport function createMemoryStorage(): Storage {\n  const forms = new Map<string, FormRecord>()\n  const versions = new Map<string, FormVersionRecord>()\n  const submissions: SubmissionRecord[] = []\n  const drafts = new Map<string, DraftRecord>()\n  const users = new Map<string, UserRecord>()\n  const apiKeys = new Map<string, ApiKeyRecord>()\n\n  return {\n    getFormByPath: async (path) => [...forms.values()].find((form) => form.path === path),\n\n    listForms: async () => [...forms.values()].map((form) => ({ ...form })),\n\n    createForm: async (record) => {\n      forms.set(record.id, { ...record })\n    },\n\n    setCurrentVersion: async (formId, versionId) => {\n      const form = forms.get(formId)\n      if (form === undefined) throw new Error(`No form \"${formId}\"`)\n      form.currentVersionId = versionId\n    },\n\n    insertVersion: async (record) => {\n      versions.set(record.id, { ...record })\n    },\n\n    getVersionById: async (id) => versions.get(id),\n\n    findVersionByHash: async (formId, hash) =>\n      [...versions.values()].find(\n        (version) => version.formId === formId && version.schemaHash === hash,\n      ),\n\n    latestVersionNumber: async (formId) =>\n      Math.max(\n        0,\n        ...[...versions.values()]\n          .filter((version) => version.formId === formId)\n          .map((version) => version.version),\n      ),\n\n    insertSubmission: async (record) => {\n      submissions.push({ ...record })\n    },\n\n    listSubmissions: async () => [...submissions],\n\n    listSubmissionsByForm: async (formId) =>\n      submissions.filter((record) => record.formId === formId).reverse(),\n\n    listVersionsByForm: async (formId) =>\n      [...versions.values()]\n        .filter((version) => version.formId === formId)\n        .sort((a, b) => b.version - a.version),\n\n    upsertDraft: async (record) => {\n      drafts.set(record.formId + ':' + record.id, { ...record })\n    },\n\n    getDraft: async (formId, draftId) => drafts.get(formId + ':' + draftId),\n\n    insertUser: async (record) => {\n      users.set(record.id, { ...record })\n    },\n\n    getUserByEmail: async (email) =>\n      [...users.values()].find((user) => user.email === email),\n\n    insertApiKey: async (record) => {\n      apiKeys.set(record.id, { ...record })\n    },\n\n    listApiKeys: async () => [...apiKeys.values()].map((key) => ({ ...key })),\n\n    findApiKeysByPrefix: async (prefix) =>\n      [...apiKeys.values()].filter((key) => key.prefix === prefix),\n\n    revokeApiKey: async (id, atIso) => {\n      const key = apiKeys.get(id)\n      if (key !== undefined) key.revokedAt = atIso\n    },\n  }\n}\n","import type { Storage } from './ports.js'\n\n/**\n * The management plane's identity and authorization, framework-free.\n *\n * Hashing and randomness are injected — this package cannot reach a CSPRNG or\n * argon2 on its own, the composition root hands them in — which keeps every\n * behaviour here testable with deterministic fakes while the real server gets\n * real cryptography.\n */\nexport type Role = 'admin' | 'editor' | 'viewer'\n\nexport interface Actor {\n  kind: 'user' | 'apiKey'\n  id: string\n  role: Role\n}\n\nexport interface AuthDeps {\n  storage: Storage\n  newId(): string\n  nowIso(): string\n  /** At least 160 bits of entropy, URL-safe. Injected, never Math.random. */\n  randomToken(): string\n  hashSecret(secret: string): Promise<string>\n  verifySecret(secret: string, hash: string): Promise<boolean>\n}\n\nconst MIN_PASSWORD_LENGTH = 10\n\nexport type CreateUserOutcome =\n  | { ok: true; id: string }\n  | { ok: false; message: string }\n\nexport async function createLocalUser(\n  deps: AuthDeps,\n  input: { email: string; password: string; role: Role },\n): Promise<CreateUserOutcome> {\n  if (input.password.length < MIN_PASSWORD_LENGTH) {\n    return { ok: false, message: `A password needs at least ${MIN_PASSWORD_LENGTH} characters.` }\n  }\n  if ((await deps.storage.getUserByEmail(input.email)) !== undefined) {\n    return { ok: false, message: 'That email is already in use.' }\n  }\n\n  const id = deps.newId()\n  await deps.storage.insertUser({\n    id,\n    email: input.email,\n    passwordHash: await deps.hashSecret(input.password),\n    role: input.role,\n    createdAt: deps.nowIso(),\n  })\n  return { ok: true, id }\n}\n\nexport type AuthOutcome = { ok: true; actor: Actor } | { ok: false }\n\n/**\n * A wrong password and an unknown email answer identically, and BOTH run a\n * hash verification — the difference in shape or timing would be a\n * user-enumeration oracle.\n */\nexport async function authenticateLocal(\n  deps: AuthDeps,\n  input: { email: string; password: string },\n): Promise<AuthOutcome> {\n  const user = await deps.storage.getUserByEmail(input.email)\n  const hash = user?.passwordHash ?? (await deps.hashSecret(`decoy:${deps.newId()}`))\n  const verified = await deps.verifySecret(input.password, hash)\n  if (user === undefined || !verified) return { ok: false }\n  return { ok: true, actor: { kind: 'user', id: user.id, role: user.role } }\n}\n\n/** The visible prefix of an API key: enough to index and to name in a UI\n *  (\"fmc_tok_a2c…\"), never enough to authenticate. */\nconst KEY_PREFIX_LENGTH = 12\n\nexport type CreateApiKeyOutcome =\n  | { ok: true; id: string; secret: string }\n  | { ok: false; message: string }\n\nexport async function createApiKey(\n  deps: AuthDeps,\n  input: { name: string; role: Role },\n): Promise<CreateApiKeyOutcome> {\n  if (input.name.trim() === '') return { ok: false, message: 'An API key needs a name.' }\n\n  // The secret exists in full exactly once — in this return value. Storage\n  // holds the prefix (for lookup and display) and a hash (for verification).\n  const secret = `fmc_${deps.randomToken()}`\n  const id = deps.newId()\n  await deps.storage.insertApiKey({\n    id,\n    name: input.name,\n    prefix: secret.slice(0, KEY_PREFIX_LENGTH),\n    secretHash: await deps.hashSecret(secret),\n    role: input.role,\n    createdAt: deps.nowIso(),\n    revokedAt: null,\n  })\n  return { ok: true, id, secret }\n}\n\nexport async function authenticateApiKey(deps: AuthDeps, presented: string): Promise<AuthOutcome> {\n  const candidates = await deps.storage.findApiKeysByPrefix(presented.slice(0, KEY_PREFIX_LENGTH))\n  for (const candidate of candidates) {\n    if (candidate.revokedAt !== null) continue\n    if (await deps.verifySecret(presented, candidate.secretHash)) {\n      return { ok: true, actor: { kind: 'apiKey', id: candidate.id, role: candidate.role } }\n    }\n  }\n  return { ok: false }\n}\n\n/**\n * The whole authorization model, in one table a reviewer can read top to\n * bottom. Deliberately NOT Postgres RLS in this phase: RLS couples the app to\n * per-request database roles and hides authorization from the test suite.\n * An unknown action is denied — permissions are granted by presence, never by\n * omission.\n */\nexport type Action =\n  | 'form.read'\n  | 'form.publish'\n  | 'submission.read'\n  | 'submission.export'\n  | 'draft.write'\n  | 'user.create'\n  | 'apiKey.create'\n\nconst VIEWER_ACTIONS: readonly Action[] = ['form.read', 'submission.read']\nconst EDITOR_ACTIONS: readonly Action[] = [\n  ...VIEWER_ACTIONS,\n  'form.publish',\n  'submission.export',\n  'draft.write',\n]\nconst ADMIN_ACTIONS: readonly Action[] = [...EDITOR_ACTIONS, 'user.create', 'apiKey.create']\n\nconst PERMISSIONS: Record<Role, ReadonlySet<Action>> = {\n  viewer: new Set(VIEWER_ACTIONS),\n  editor: new Set(EDITOR_ACTIONS),\n  admin: new Set(ADMIN_ACTIONS),\n}\n\nexport function can(actor: Actor, action: Action): boolean {\n  return PERMISSIONS[actor.role].has(action)\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@formancy/server-core",
+  "version": "0.1.0",
+  "description": "The formancy backend's use-cases: publish, resolve, revalidate, store — framework-free, against repository ports.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@formancy/core": "0.1.0",
+    "@formancy/spec": "0.1.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "publint": "^0.3.24",
+    "tsdown": "^0.23.0",
+    "typescript": "~6.0.3",
+    "unrun": "^0.3.1",
+    "vitest": "^5.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sharkysan/formancy.ai.git",
+    "directory": "packages/server-core"
+  },
+  "homepage": "https://github.com/sharkysan/formancy.ai",
+  "bugs": "https://github.com/sharkysan/formancy.ai/issues",
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "check:pkg": "publint && attw --pack . --profile esm-only"
+  }
+}