@sequenceholdings/artifact-studio 0.3.0 → 0.3.1

package/dist/tunnel/redis.d.ts

@@ -1,17 +1,20 @@
 import type { TunnelLease } from './broker.js';
 import type { TunnelRelay, TunnelSocket } from './transport.js';
-import { type RedisTunnelRelayOptions } from './redis-types.js';
+import type { RedisTunnelRelayOptions } from './redis-types.js';
 export { RedisTunnelOwnership } from './redis-ownership.js';
 export type { RedisTunnelCommands } from './redis-ownership.js';
 export type { RedisTunnelPublisher, RedisTunnelSubscriber, RedisTunnelRelayOptions } from './redis-types.js';
 /** Internal Redis channels contain authorized application traffic. Deploy them
- * on the environment's private, authenticated Redis and disable command replay. */
+ * on the environment's private, authenticated Redis and disable command replay.
+ * Every message is authenticated with a gateway-only key: other Redis clients
+ * can neither inject, redirect nor replay tunnel frames. */
 export declare class RedisTunnelRelay implements TunnelRelay {
     private readonly options;
     private started;
     private closed;
     private readonly attached;
     private readonly connected;
+    private readonly frames;
     private publishing;
     private receiving;
     private outgoingBytes;

package/dist/tunnel/redis.js

@@ -2,16 +2,19 @@ import { randomUUID } from 'node:crypto';
 import { DEFAULT_TUNNEL_LIMITS, parseTunnelFrame } from './protocol.js';
 import { redisIdentifier as identifier, redisNamespaceSchema as namespaceSchema, redisLeaseSchema as leaseSchema } from './redis-ownership.js';
 import { RelaySocket } from './redis-socket.js';
-import { envelopeSchema } from './redis-types.js';
+import { deriveRelayFrameKey, RelayFrameAuthenticator } from './redis-auth.js';
 export { RedisTunnelOwnership } from './redis-ownership.js';
 /** Internal Redis channels contain authorized application traffic. Deploy them
- * on the environment's private, authenticated Redis and disable command replay. */
+ * on the environment's private, authenticated Redis and disable command replay.
+ * Every message is authenticated with a gateway-only key: other Redis clients
+ * can neither inject, redirect nor replay tunnel frames. */
 export class RedisTunnelRelay {
     options;
     started = false;
     closed = false;
     attached = new Map();
     connected = new Map();
+    frames;
     publishing = Promise.resolve();
     receiving = Promise.resolve();
     outgoingBytes = 0;
@@ -24,6 +27,7 @@ export class RedisTunnelRelay {
         namespaceSchema.parse(options.namespace);
         if (options.namespace !== options.ownership.namespace || Object.is(options.publisher, options.subscriber))
             throw new Error('Separate, environment-scoped Redis clients are required');
+        this.frames = new RelayFrameAuthenticator(deriveRelayFrameKey({ secret: options.secret, namespace: options.namespace }));
         if (options.connectTimeoutMs !== undefined && (!Number.isSafeInteger(options.connectTimeoutMs) || options.connectTimeoutMs < 1 || options.connectTimeoutMs > 60_000))
             throw new Error('Invalid tunnel connect timeout');
         const policy = options.publisher.options;
@@ -93,8 +97,15 @@ export class RedisTunnelRelay {
     onMessage = (channel, raw) => {
         if (!this.started || channel !== this.channel(this.options.nodeId))
             return;
+        // Authenticate before anything else: a message without a valid MAC, fresh timestamp and new
+        // sequence is dropped without resetting live traffic, so a Redis client cannot inject or DoS.
+        const envelope = this.frames.open({ channel, message: raw });
+        if (!envelope) {
+            this.options.onRejectedFrame?.();
+            return;
+        }
         const bytes = Buffer.byteLength(raw);
-        if (bytes > DEFAULT_TUNNEL_LIMITS.maxFrameBytes * 2 + 2048 || this.incomingBytes + bytes > DEFAULT_TUNNEL_LIMITS.maxBufferedBytes) {
+        if (this.incomingBytes + bytes > DEFAULT_TUNNEL_LIMITS.maxBufferedBytes) {
             this.onRelayOverload();
             return;
         }
@@ -102,11 +113,13 @@ export class RedisTunnelRelay {
         const generation = this.generation;
         this.receiving = this.receiving.then(async () => {
             if (this.started && generation === this.generation)
-                await this.receive(envelopeSchema.parse(JSON.parse(raw)));
+                await this.receive(envelope);
         }).catch(() => this.onRelayOverload()).finally(() => { this.incomingBytes -= bytes; });
     };
     publish(nodeId, envelope) {
-        const payload = JSON.stringify(envelope);
+        const channel = this.channel(nodeId);
+        // Sealed in call order, so each destination sees this node's sequence numbers ascending.
+        const payload = this.frames.seal({ channel, envelope });
         const bytes = Buffer.byteLength(payload);
         if (this.outgoingBytes + bytes > DEFAULT_TUNNEL_LIMITS.maxBufferedBytes)
             return Promise.reject(new Error('Tunnel relay publish queue exceeded'));
@@ -115,7 +128,7 @@ export class RedisTunnelRelay {
         const sending = this.publishing.then(async () => {
             if (envelope.type !== 'close' && (generation !== this.generation || !this.started || this.closed))
                 throw new Error('Tunnel relay generation changed');
-            if (await this.options.publisher.publish(this.channel(nodeId), payload) < 1)
+            if (await this.options.publisher.publish(channel, payload) < 1)
                 throw new Error('Tunnel node is offline');
         });
         this.publishing = sending.catch(() => undefined).finally(() => { this.outgoingBytes -= bytes; });

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "SDK types and CLI library for building Artifact Studio apps. Driven via `seq-studio artifact <sub>` (@sequenceholdings/studio-cli), which runs the `./cli` runCli export.",
   "type": "module",
   "exports": {

package/templates/nextjs/README.md

@@ -71,6 +71,12 @@ only the capabilities the application needs, then configure authorized resource
 bindings in Atlas. Local development uses explicit nonproduction resources and
 never falls back to production when a binding is missing.
 
+ORM access is declared per table and per mutation: list `<namespace>/<table>`
+under `data.read` for every table a query reads (queries that follow
+platform-user relations also read `<namespace>/platformUsers`). Under
+`data.write`, use `<namespace>/ops/<Operation>` for each persisted mutation the
+app runs, or `<namespace>/<table>` for table-level coverage.
+
 Managed secrets stay in hosted runtimes. For local integration tests, use your
 own test credentials, mocks or an existing governed function. Use a hosted
 preview for application code that needs a managed secret. Never put secrets in

package/templates/nextjs/gitignore

@@ -0,0 +1,9 @@
+node_modules/
+.next/
+next-env.d.ts
+.artifact/
+.artifact-studio/
+.env*
+*.tsbuildinfo
+coverage/
+.DS_Store

package/templates/nextjs/pnpm-workspace.yaml

@@ -2,7 +2,21 @@ packages:
   - '.'
 
 minimumReleaseAge: 10080
+# The Sequence SDK chain is published from the Studio repo's audited release
+# pipeline, so a new artifact-studio release must install without waiting out
+# the seven-day quarantine. Scoped to the exact first-party packages a fresh
+# scaffold resolves, not @sequenceholdings/*.
+minimumReleaseAgeExclude:
+  - '@sequenceholdings/artifact-studio'
+  - '@sequenceholdings/atlas-ui'
+  - '@sequenceholdings/custom-roles-manifest'
+  - '@sequenceholdings/lattice-form-renderer'
+  - '@sequenceholdings/orm'
+  - '@sequenceholdings/storage'
 strictDepBuilds: true
 allowBuilds:
   '@tailwindcss/oxide': false
+  # Reached through the SDK's static builder and ORM tooling, never run by a
+  # Next.js app; its platform binary installs as an optional dependency.
+  esbuild: false
   sharp: false