@abloatai/ablo 0.25.0 → 0.26.0

package/dist/schema/schema.js

@@ -25,7 +25,7 @@ import { scopeSchema, grantsRefSchema } from './roles.js';
 // Sync-group roles (identity + entity) live in `./roles.js`. Re-exported here
 // so the long-standing `@ablo/schema` / `./schema.js` import paths keep working
 // after the rehome — see roles.ts for the full vocabulary.
-export { identityRole, entityRole, extractIdentityIds, extractEntityIds, composeIdentitySyncGroups, composeEntitySyncGroups, syncGroup, syncGroupSchema, syncGroupInputSchema, isSyncGroupInput, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, groupsInputSchema, } from './roles.js';
+export { identityRole, entityRole, extractIdentityIds, extractEntityIds, composeIdentitySyncGroups, composeEntitySyncGroups, intersectRequestedWithAllowed, syncGroup, syncGroupSchema, syncGroupInputSchema, isSyncGroupInput, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, groupsInputSchema, } from './roles.js';
 function resolveCasing(fn) {
     if (fn === undefined)
         return (x) => x;
@@ -108,17 +108,18 @@ function assertRoundTrippableCamelCase(modelName, fieldName) {
         return;
     // Leading-lowercase constraint: fields must be camelCase, not PascalCase.
     // PascalCase is reserved for typenames.
-    if (fieldName[0] >= 'A' && fieldName[0] <= 'Z') {
+    const first = fieldName.charAt(0);
+    if (first >= 'A' && first <= 'Z') {
         throw new AbloValidationError(`[defineSchema] ${modelName}.${fieldName}: field names must start lowercase ` +
-            `(camelCase). Use "${fieldName[0].toLowerCase()}${fieldName.slice(1)}" instead.`, { code: 'schema_field_not_camelcase' });
+            `(camelCase). Use "${first.toLowerCase()}${fieldName.slice(1)}" instead.`, { code: 'schema_field_not_camelcase' });
     }
     // Two-consecutive-uppercase check. The classic failure mode is
     // `contentJSON`, `contentHTML`, `myURLParam`, etc. These don't round-trip
     // through `postgres.camel` — the snake_case intermediate would be
     // `content_j_s_o_n`, which is not a column that exists.
     for (let i = 0; i < fieldName.length - 1; i++) {
-        const a = fieldName[i];
-        const b = fieldName[i + 1];
+        const a = fieldName.charAt(i);
+        const b = fieldName.charAt(i + 1);
         const aUpper = a >= 'A' && a <= 'Z';
         const bUpper = b >= 'A' && b <= 'Z';
         if (aUpper && bUpper) {
@@ -184,8 +185,7 @@ export function defineSchema(models, options) {
         // columns stay declared in the artifact instead of rediscovered by
         // SQL compilers. Server-side SQL compilers read the resolved value
         // directly.
-        for (const relName of Object.keys(def.relations)) {
-            const rel = def.relations[relName];
+        for (const rel of Object.values(def.relations)) {
             const fieldColumn = def.fields[rel.foreignKey]?.column;
             rel.foreignKeyColumn = fieldColumn ?? casing(rel.foreignKey);
         }
@@ -245,6 +245,10 @@ function validateSyncGroupSchema(models) {
         // The scope edge must target a model that is actually a scope root —
         // otherwise the resolved `<kind>:<id>` group is one nothing fans into.
         const scopeRel = relations[def.grants.scope];
+        // Unreachable: the role loop above already threw if the scope relation
+        // is missing — this narrows the indexed access for the checks below.
+        if (!scopeRel)
+            continue;
         const target = models[scopeRel.target];
         if (target && !target.scope) {
             throw new AbloValidationError(`Model "${name}": grants.scope "${def.grants.scope}" targets "${scopeRel.target}", ` +

package/dist/schema/serialize.d.ts

@@ -30,10 +30,10 @@
  */
 import type { FieldMeta } from './field.js';
 import type { Tenancy } from './tenancy.js';
-import type { SchemaPlane } from './plane.js';
+import type { ModelResidency } from './residency.js';
 import type { GrantsRef, LoadStrategy, PersistOptions, AutoFillRule, ConflictAxis } from './model.js';
 import type { RelationType } from './relation.js';
-import { type Schema, type SchemaRecord, type IdentityRole, type EntityRole } from './schema.js';
+import { type Schema, type IdentityRole, type EntityRole } from './schema.js';
 /** Current schema-JSON envelope version. Bump on a breaking change to the
  * JSON shape itself (not the user's schema). v2 replaced the per-model
  * `syncGroupFormat` template string with structured `scope`/`grants`/
@@ -58,7 +58,7 @@ export interface ModelJSON {
     readonly tenancy: Tenancy;
     /** Database plane. Optional for back-compat: absent in artifacts written before
      *  the plane axis → read as `tenant` (the default). See `./plane.ts`. */
-    readonly plane?: SchemaPlane;
+    readonly plane?: ModelResidency;
     readonly scope?: boolean | string;
     readonly grants?: GrantsRef;
     readonly entityRoles?: readonly EntityRole[];
@@ -84,18 +84,18 @@ export interface SchemaJSON {
  * (validators, `computed`); keeps everything the server and a faithful
  * rebuild need. The result is plain data — `JSON.stringify`-safe.
  */
-export declare function toSchemaJSON(schema: Schema<SchemaRecord>): SchemaJSON;
+export declare function toSchemaJSON(schema: Schema): SchemaJSON;
 /** Serialize a `Schema` to a JSON string (the `ablo push` payload). */
-export declare function serializeSchema(schema: Schema<SchemaRecord>): string;
+export declare function serializeSchema(schema: Schema): string;
 /**
  * Reconstruct a working `Schema` from its JSON form. Validators are rebuilt
  * permissively from field metadata (the server never validates field shapes);
  * `computed` getters are absent. Everything the server reads — routing,
  * scoping, relations, identity roles — is restored exactly.
  */
-export declare function fromSchemaJSON(json: SchemaJSON): Schema<SchemaRecord>;
+export declare function fromSchemaJSON(json: SchemaJSON): Schema;
 /** Parse a `Schema` from a JSON string (inverse of {@link serializeSchema}). */
-export declare function parseSchema(json: string): Schema<SchemaRecord>;
+export declare function parseSchema(json: string): Schema;
 /**
  * Stable content hash of a `Schema`'s JSON form. FNV-1a over a canonical
  * (sorted-key) encoding — deterministic across runs and order-invariant, no
@@ -103,5 +103,5 @@ export declare function parseSchema(json: string): Schema<SchemaRecord>;
  * the hash it was built against, the server compares it to the tenant's
  * active schema hash. Not a security primitive.
  */
-export declare function schemaHash(schema: Schema<SchemaRecord>): string;
+export declare function schemaHash(schema: Schema): string;
 export {};

package/dist/schema/sync-delta-row.d.ts

@@ -17,7 +17,7 @@
  *   - {@link deltaProvenanceSchema}  — which AI task caused it. `control` plane.
  *
  * {@link syncDeltaRowSchema} is the full stored row (core ∪ attribution ∪
- * provenance). {@link DELTA_PLANES} declares each slice's plane so provisioning
+ * provenance). {@link DELTA_RESIDENCY} declares each slice's plane so provisioning
  * (P1) can derive "what a customer DB gets" from the schema, not hand-code it.
  *
  * Distinct from the WIRE `SyncDelta` (`sync/SyncWebSocket.ts`, client-facing) and
@@ -152,7 +152,7 @@ export type SyncDeltaRow = z.infer<typeof syncDeltaRowSchema>;
  * hand-coding the boundary; the BYO outbox writes the `tenant` slice and the
  * relay enriches the `control` slices in Ablo's own database.
  */
-export declare const DELTA_PLANES: {
+export declare const DELTA_RESIDENCY: {
     readonly core: "tenant";
     readonly attribution: "control";
     readonly provenance: "control";

package/dist/schema/sync-delta-row.js

@@ -17,7 +17,7 @@
  *   - {@link deltaProvenanceSchema}  — which AI task caused it. `control` plane.
  *
  * {@link syncDeltaRowSchema} is the full stored row (core ∪ attribution ∪
- * provenance). {@link DELTA_PLANES} declares each slice's plane so provisioning
+ * provenance). {@link DELTA_RESIDENCY} declares each slice's plane so provisioning
  * (P1) can derive "what a customer DB gets" from the schema, not hand-code it.
  *
  * Distinct from the WIRE `SyncDelta` (`sync/SyncWebSocket.ts`, client-facing) and
@@ -96,7 +96,7 @@ export const syncDeltaRowSchema = syncDeltaCoreSchema
  * hand-coding the boundary; the BYO outbox writes the `tenant` slice and the
  * relay enriches the `control` slices in Ablo's own database.
  */
-export const DELTA_PLANES = {
+export const DELTA_RESIDENCY = {
     core: 'tenant',
     attribution: 'control',
     provenance: 'control',

package/dist/server/storage-mode.d.ts

@@ -1 +1,8 @@
-export {};
+/** See module note — host-deployment vocabulary, never customer-facing. */
+export declare const storageModeSchema: z.ZodEnum<{
+    source: "source";
+    hosted: "hosted";
+    selfHosted: "selfHosted";
+}>;
+/** See module note — host-deployment vocabulary, never customer-facing. */
+export type StorageMode = z.infer<typeof storageModeSchema>;

package/dist/server/storage-mode.js

@@ -8,11 +8,21 @@
  *   - `selfHosted` — the customer's database, same execution path as hosted.
  *   - `source`     — a customer-owned endpoint (credentialless ingestion).
  *
- * @internal Deployment topology, not product vocabulary. Customers never see a
- * "storage mode" — their story is `Ablo({ schema, apiKey, databaseUrl })` and
- * one `datasource` resource (docs/plans/sync-engine-stripe-story-scope.md).
+ * Deployment topology, not product vocabulary. Customers never see a
+ * "storage mode" — their story is `ablo connect` (WAL replication: reads tail
+ * their database's logical-replication stream, the data stays in their DB)
+ * with the signed `dataSource()` endpoint as the marked fallback (ADR 0002,
+ * docs/decisions/0002-read-path-logical-replication-vs-data-hosting.md).
+ * The `databaseUrl` dial-in that this enum's `selfHosted` arm serves is
+ * DEPRECATED pending the WAL read cutover — do not build on it.
  * This export exists for the sync-server host only.
+ *
+ * NOT `@internal`-tagged: tsconfig.build.json sets `stripInternal`, and these
+ * symbols are re-exported by `server/index.ts` — tagging them strips them from
+ * the emitted d.ts, leaving an empty `export {}` module behind a live
+ * re-export. `skipLibCheck` masks the break and `StorageMode` silently
+ * degrades to an error-any for every dist consumer (the sync-server host).
  */
 import { z } from 'zod';
-/** @internal See module note — host-deployment vocabulary, never customer-facing. */
+/** See module note — host-deployment vocabulary, never customer-facing. */
 export const storageModeSchema = z.enum(['hosted', 'source', 'selfHosted']);

package/dist/source/adapter.d.ts

@@ -17,7 +17,7 @@
  * core handler's `commit` / `events` / per-model `load`+`list` — no per-ORM
  * branching anywhere above the adapter.
  */
-import type { SourceListQuery, SourceRequestContext } from './index.js';
+import type { SourceListQuery, SourceRequestContext } from './types.js';
 import type { AdapterCapabilities, ChangeSet, EventsPage, Migration } from './contract.js';
 /**
  * A canonical row keyed by schema FIELD name (e.g. `operatorId`) — the SDK shape,

package/dist/source/adapters/drizzle.js

@@ -144,8 +144,9 @@ export function drizzleDataSource(db, schema) {
         async commit(change) {
             return db.transaction(async (tx) => {
                 const cached = rowsOf(await tx.execute(sql `SELECT response FROM ablo_idempotency WHERE client_tx_id = ${change.clientTxId} LIMIT 1`));
-                if (cached.length > 0)
-                    return { rows: cached[0].response };
+                const cachedRow = cached[0];
+                if (cachedRow)
+                    return { rows: cachedRow.response };
                 const rows = [];
                 for (const [index, op] of change.operations.entries()) {
                     const row = await applyOperation(tx, op);
@@ -180,7 +181,7 @@ export function drizzleDataSource(db, schema) {
                 occurredAt: r.occurred_at != null ? Number(r.occurred_at) : null,
                 cursor: String(r.cursor),
             }));
-            return { events, nextCursor: events.length > 0 ? events[events.length - 1].cursor : null };
+            return { events, nextCursor: events.at(-1)?.cursor ?? null };
         },
     };
 }

package/dist/source/adapters/kysely.js

@@ -153,8 +153,9 @@ export function kyselyDataSource(db, schema) {
                     .where('client_tx_id', '=', change.clientTxId)
                     .limit(1)
                     .execute();
-                if (cached.length > 0) {
-                    const response = cached[0].response;
+                const cachedRow = cached[0];
+                if (cachedRow) {
+                    const response = cachedRow.response;
                     return {
                         rows: (typeof response === 'string' ? JSON.parse(response) : response),
                     };
@@ -204,7 +205,7 @@ export function kyselyDataSource(db, schema) {
                 occurredAt: r.occurred_at != null ? Number(r.occurred_at) : null,
                 cursor: String(r.cursor),
             }));
-            return { events, nextCursor: events.length > 0 ? events[events.length - 1].cursor : null };
+            return { events, nextCursor: events.at(-1)?.cursor ?? null };
         },
     };
 }

package/dist/source/adapters/memory.js

@@ -108,7 +108,7 @@ export function memoryDataSource() {
             const page = outbox.filter((e) => Number(e.cursor) > after).slice(0, limit);
             return {
                 events: page,
-                nextCursor: page.length > 0 ? page[page.length - 1].cursor : null,
+                nextCursor: page.at(-1)?.cursor ?? null,
             };
         },
     };

package/dist/source/adapters/prisma.js

@@ -15,7 +15,7 @@
 import { AbloValidationError } from '../../errors.js';
 import { outboxEventSchema } from '../contract.js';
 import { adapterTableMigrations } from '../migrations.js';
-const lowerFirst = (s) => (s ? s[0].toLowerCase() + s.slice(1) : s);
+const lowerFirst = (s) => (s ? s.charAt(0).toLowerCase() + s.slice(1) : s);
 /**
  * Resolve a model's Prisma delegate by name. This is the ONE irreducible cast in
  * the adapter layer, and it's a genuine type-system limit, not laziness:
@@ -138,8 +138,9 @@ export function prismaDataSource(prisma, schema, options = {}) {
             return prisma.$transaction(async (tx) => {
                 // Idempotency: a duplicate clientTxId returns the original rows, no re-apply.
                 const cached = await tx.$queryRawUnsafe(`SELECT response FROM ablo_idempotency WHERE client_tx_id = $1 LIMIT 1`, change.clientTxId);
-                if (cached.length > 0)
-                    return { rows: cached[0].response };
+                const cachedRow = cached[0];
+                if (cachedRow)
+                    return { rows: cachedRow.response };
                 const rows = [];
                 for (const [index, op] of change.operations.entries()) {
                     const row = await applyOperation(tx, op);
@@ -170,7 +171,7 @@ export function prismaDataSource(prisma, schema, options = {}) {
             }));
             return {
                 events,
-                nextCursor: events.length > 0 ? events[events.length - 1].cursor : null,
+                nextCursor: events.at(-1)?.cursor ?? null,
             };
         },
     };

package/dist/source/conformance.js

@@ -29,8 +29,10 @@ export function dataSourceConformanceChecks(make) {
                 const adapter = await make();
                 const result = await adapter.commit(change('tx_create', [{ type: 'CREATE', model: 'task', id: 't1', input: { title: 'A' } }]));
                 assert.equal(result.rows.length, 1, 'one row returned');
-                assert.equal(result.rows[0].id, 't1');
-                assert.equal(result.rows[0].title, 'A');
+                const created = result.rows[0];
+                assert.ok(created, 'one row returned');
+                assert.equal(created.id, 't1');
+                assert.equal(created.title, 'A');
             },
         },
         {
@@ -40,7 +42,7 @@ export function dataSourceConformanceChecks(make) {
                 await adapter.commit(change('tx1', [{ type: 'CREATE', model: 'task', id: 't1', input: { title: 'A' } }]));
                 const found = await adapter.read({ kind: 'load', model: 'task', id: 't1' });
                 assert.equal(found.length, 1);
-                assert.equal(found[0].title, 'A');
+                assert.equal(found[0]?.title, 'A');
                 const missing = await adapter.read({ kind: 'load', model: 'task', id: 'nope' });
                 assert.equal(missing.length, 0, 'unknown id reads empty');
             },
@@ -54,7 +56,7 @@ export function dataSourceConformanceChecks(make) {
                     { type: 'CREATE', model: 'task', id: 't2', input: { title: 'B' } },
                 ]));
                 const rows = await adapter.read({ kind: 'list', model: 'task' });
-                const ids = rows.map((r) => r.id).sort();
+                const ids = rows.map((r) => (r).id).sort();
                 assert.deepEqual(ids, ['t1', 't2']);
             },
         },
@@ -83,9 +85,9 @@ export function dataSourceConformanceChecks(make) {
                 assert.ok(page.events.length >= 1, 'at least one event');
                 const evt = page.events.find((e) => e.entityId === 't1');
                 assert.ok(evt, 'event for the committed row');
-                assert.equal(evt?.model, 'task');
-                assert.equal(evt?.type, 'CREATE');
-                assert.equal(evt?.clientTxId, 'tx_evt');
+                assert.equal(evt.model, 'task');
+                assert.equal(evt.type, 'CREATE');
+                assert.equal(evt.clientTxId, 'tx_evt');
             },
         },
         {
@@ -115,7 +117,7 @@ export function dataSourceConformanceChecks(make) {
                 await adapter.commit(change('tx_c1', [{ type: 'CREATE', model: 'task', id: 't1', input: { title: 'A' } }]));
                 await adapter.commit(change('tx_u1', [{ type: 'UPDATE', model: 'task', id: 't1', input: { title: 'B' } }]));
                 const found = await adapter.read({ kind: 'load', model: 'task', id: 't1' });
-                assert.equal(found[0].title, 'B', 'update applied');
+                assert.equal(found[0]?.title, 'B', 'update applied');
             },
         },
     ];

package/dist/source/connector.js

@@ -26,8 +26,10 @@
  * path. The transport changes; the trust model does not.
  */
 import { SOURCE_CONNECTOR_PROTOCOL_VERSION, SOURCE_CONNECTOR_WS_PATH, sourceConnectorSubprotocols, encodeFrame, decodeFrame, ConnectorProtocolError, } from './connector-protocol.js';
-/** Default Ablo Cloud base. The connector appends `SOURCE_CONNECTOR_WS_PATH`. */
-const DEFAULT_BASE_URL = 'https://api.abloatai.com';
+import { ABLO_HOSTED_HTTP_BASE_URL } from '../client/hostedEndpoints.js';
+/** Default Ablo Cloud base. The connector appends `SOURCE_CONNECTOR_WS_PATH`.
+ *  Single-sourced from the dependency-free hosted-endpoints leaf. */
+const DEFAULT_BASE_URL = ABLO_HOSTED_HTTP_BASE_URL;
 /**
  * Reconnect backoff, in ms, indexed by consecutive failed connect attempts.
  * Unlike the (multi-day) Standard Webhooks delivery schedule, a long-lived

package/dist/source/factory.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The `abloSource()` / `dataSource()` endpoint factory — the customer-owned
+ * Data Source handler. Takes the options (schema, apiKey, handlers or ORM
+ * adapter), verifies the signed request, enforces per-key scopes, and
+ * dispatches the four wire operations (`load`/`list`/`commit`/`events`) to
+ * the configured handlers.
+ *
+ * `AbloSourceOptions` lives here (not `types.ts`) because it references the
+ * ORM `DataSourceAdapter` — keeping it with the factory keeps `types.ts` a
+ * dependency-free leaf for `adapter.ts`/`contract.ts` to import from.
+ */
+import type { Schema, SchemaRecord, InferCreate } from '../schema/schema.js';
+import type { DataSourceAdapter } from './adapter.js';
+import type { SourceApiKey, SourceAuthorizeContext, SourceCommitHandler, SourceEventsHandler, SourceModelHandlers, SourceRequest, SourceScope } from './types.js';
+type SourceModels<S extends SchemaRecord, TAuth> = Partial<{
+    readonly [K in keyof S & string]: SourceModelHandlers<InferCreate<Schema<S>, K> & {
+        readonly id: string;
+    } & Record<string, unknown>, InferCreate<Schema<S>, K>, TAuth>;
+}>;
+export type AbloSourceOptions<S extends SchemaRecord, TAuth = unknown> = {
+    readonly schema: Schema<S>;
+    /**
+     * Customer-visible Ablo credential. In the API-key-only onboarding
+     * path, Ablo signs Data Source calls with the same project API key
+     * that the customer's server-side SDK uses. This keeps the customer
+     * env surface to one Ablo credential while preserving signed request
+     * verification before any handler runs.
+     */
+    readonly apiKey: SourceApiKey;
+    /**
+     * Clock-skew window for signed source requests. Default: 5 minutes.
+     */
+    readonly signatureToleranceMs?: number;
+    /**
+     * Verify the Ablo request and return customer-owned context such as
+     * a database handle, account scope, or current actor. Keep database
+     * credentials in this function's environment; never send them to Ablo.
+     *
+     * Signature verification is handled by `apiKey` before this function
+     * runs. `authorize` should only attach business context.
+     */
+    readonly authorize?: (context: SourceAuthorizeContext) => Promise<TAuth> | TAuth;
+    /**
+     * Optional per-request scope resolver. When set, the helper checks
+     * the resolved scope set against the request's operation
+     * (`load`/`list`/`commit`/`events`) and returns 403
+     * `source_forbidden` if not allowed — before any model handler
+     * runs.
+     *
+     * Customers typically extract a key id from the request (e.g.
+     * `webhook-id` prefix, a custom header, or the API key itself) and
+     * look up the scopes for that key in their store.
+     *
+     * When omitted, all operations are allowed. Returning an empty set
+     * denies all operations.
+     */
+    readonly resolveScopes?: (params: {
+        readonly auth: TAuth;
+        readonly request: Request;
+        readonly body: SourceRequest;
+    }) => Promise<ReadonlySet<SourceScope> | readonly SourceScope[]> | ReadonlySet<SourceScope> | readonly SourceScope[];
+    /**
+     * Top-level atomic commit handler. Prefer this for real applications:
+     * one UI/action commit can span several models and should run inside
+     * one customer-owned transaction.
+     */
+    readonly commit?: SourceCommitHandler<TAuth>;
+    /**
+     * External-write feed. Ablo polls this to learn about changes that
+     * happened outside the SDK (cron jobs, dashboard edits, batch
+     * imports). Each returned event becomes a delta and fans out to
+     * connected clients.
+     *
+     * Handlers may return the raw outbox feed. Ablo dedupes stable
+     * `event.id` values and filters SDK-origin echoes when rows carry
+     * the originating `clientTxId`; customers should persist both fields
+     * in their outbox table.
+     */
+    readonly events?: SourceEventsHandler<TAuth>;
+    /**
+     * Optional grouped form. The object-key form below is usually terser:
+     * `abloSource({ schema, files: { load, list, commit } })`.
+     */
+    readonly models?: SourceModels<S, TAuth>;
+    /**
+     * An ORM adapter (`prismaDataSource(prisma, schema)`, …). When set, it serves
+     * ALL four operations — read (load/list), commit (idempotent + outbox), and
+     * events — so no hand-written `commit`/`events`/model handlers are needed. The
+     * adapter is consumed at the generic dispatch layer (rows are JSON on the wire),
+     * which is why it carries no per-model types and needs no cast at the call site.
+     * Mutually exclusive with hand-written handlers.
+     */
+    readonly adapter?: DataSourceAdapter;
+} & SourceModels<S, TAuth>;
+/**
+ * Create a customer-owned data source endpoint.
+ *
+ * App code still talks to Ablo with `ablo.files.load/list/update`.
+ * This helper is only for customers who keep canonical rows in their own
+ * database and want Ablo Cloud to call a narrow, signed endpoint instead
+ * of receiving database credentials.
+ */
+export declare function abloSource<const S extends SchemaRecord, TAuth = unknown>(options: AbloSourceOptions<S, TAuth>): (request: Request) => Promise<Response>;
+export type DataSourceOptions<S extends SchemaRecord, TAuth = unknown> = AbloSourceOptions<S, TAuth>;
+export declare function dataSource<const S extends SchemaRecord, TAuth = unknown>(options: DataSourceOptions<S, TAuth>): (request: Request) => Promise<Response>;
+export {};