@feasibleone/blong-gogo 1.26.0 → 1.27.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.27.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.26.0...blong-gogo-v1.27.0) (2026-07-23)
+
+
+### Features
+
+* compress static assets ([a0a376d](https://github.com/feasibleone/blong/commit/a0a376dc141a8b3041ad0c83895bd3de5675c2e2))
+* static routes ([b544ca3](https://github.com/feasibleone/blong/commit/b544ca3b4c3ed858457c93f21b8523147c30bf59))
+
 ## [1.26.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.25.1...blong-gogo-v1.26.0) (2026-07-14)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -25,6 +25,8 @@
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.2.0",
     "@fastify/deepmerge": "^3.2.1",
+    "@fastify/helmet": "^13.1.0",
+    "@fastify/static": "^10.1.0",
     "@fastify/swagger": "^9.7.0",
     "@fastify/swagger-ui": "^5.2.5",
     "@fastify/type-provider-typebox": "^6.1.0",
@@ -84,7 +86,7 @@
     "playwright": "^1.60.0",
     "tap": "^21.6.3",
     "typescript": "^6.0.3",
-    "@feasibleone/blong-dev": "1.1.0"
+    "@feasibleone/blong-dev": "1.1.1"
   },
   "scripts": {
     "browser-check": "node scripts/browser-compat-check.mjs",

package/src/Gateway.ts

@@ -83,6 +83,9 @@ interface IConfig extends IConfigMLE {
         cache: object;
         audience: string;
     };
+    static?: {
+        root: string;
+    };
 }
 
 function operationParams(
@@ -610,6 +613,11 @@ export default class Gateway extends Internal implements IGateway {
                 methodId: methodId,
                 methodParts: methodParts,
             });
+            if (this.#config.static)
+                await this.#server.register(
+                    (await import('./static.ts')).default,
+                    this.#config.static,
+                );
             if (this.#config.cors)
                 await this.#server.register((await import('./cors.ts')).default, this.#config.cors);
             if (this.#config.sign || this.#config.encrypt) {

package/src/Watch.ts

@@ -195,7 +195,8 @@ export default class Watch extends Internal implements IWatch {
             },
             [[] as string[], [] as string[]],
         );
-        const {Formatter, TypeScriptToTypeBox} = await import('@sinclair/typebox-codegen');
+        const codeGen = '@sinclair/typebox-codegen';
+        const {Formatter, TypeScriptToTypeBox} = await import(/* @vite-ignore */ codeGen);
         if (schema.length)
             this.#platform.writeFileSync(
                 this.#platform.join(dir, '~.schema.ts'),

package/src/jwt.ts

@@ -5,6 +5,7 @@ import {type Errors, type ILocal} from '@feasibleone/blong/types';
 import type {FastifyInstance, FastifyPluginOptions, FastifyReply, FastifyRequest} from 'fastify';
 import fp from 'fastify-plugin';
 import {LRUCache} from 'lru-cache';
+import isPublic from './public.ts';
 
 import {type IGatewayCodec} from './GatewayCodec.ts';
 
@@ -65,7 +66,7 @@ export default fp<{
             'preValidation',
             function (request: FastifyRequest, reply: FastifyReply, done: (err?: Error) => void) {
                 const auth = request.routeOptions.config.auth;
-                if (auth !== false && !request.originalUrl.startsWith('/documentation')) {
+                if (auth !== false && !isPublic(request.originalUrl)) {
                     if (auth === 'login') {
                         request.auth = {credentials: {mlek: 'header', mlsk: 'header'}};
                         done();

package/src/load.ts

@@ -25,6 +25,7 @@ import {methodParts} from './lib.ts';
 import layerProxy from './layerProxy.ts';
 import RealmImpl, {type IRealm} from './Realm.ts';
 import type {IWatch} from './Watch.ts';
+const extension = '.ts';
 
 const LAYER_FILE = 'layer' as const;
 
@@ -444,6 +445,7 @@ export default async function loadRealm<T extends TSchema>(
                             },
                             gateway: {
                                 port: 0,
+                                static: {},
                                 // Static development keys, so sessions survive server hot-reloads
                                 /* cSpell:disable */
                                 sign: {
@@ -487,7 +489,7 @@ export default async function loadRealm<T extends TSchema>(
                 load: () =>
                     rootKind === 'browser' && globalThis.window
                         ? import('./BrowserLog.ts')
-                        : import('./Log.ts'),
+                        : import(/* vite-ignore */ './Log' + extension),
             },
             {
                 name: 'apiSchema',
@@ -551,27 +553,27 @@ export default async function loadRealm<T extends TSchema>(
                       {
                           name: 'remote',
                           deps: ['log', 'local'],
-                          load: () => import('./RpcClient.ts'),
+                          load: () => import(/* @vite-ignore */ './RpcClient' + extension),
                       },
                       {
                           name: 'rpcServer',
                           deps: ['log'],
-                          load: () => import('./RpcServer.ts'),
+                          load: () => import(/* @vite-ignore */ './RpcServer' + extension),
                       },
                       {
                           name: 'gateway',
                           deps: ['log'],
-                          load: () => import('./Gateway.ts'),
+                          load: () => import(/* @vite-ignore */ './Gateway' + extension),
                       },
                       {
                           name: 'restFs',
                           deps: ['log', 'gateway'],
-                          load: () => import('./RestFs.ts'),
+                          load: () => import(/* @vite-ignore */ './RestFs' + extension),
                       },
                       {
                           name: 'systemDebug',
                           deps: ['log', 'gateway', 'registry', 'rpcServer'],
-                          load: () => import('./SystemDebug.ts'),
+                          load: () => import(/* @vite-ignore */ './SystemDebug' + extension),
                       },
                       {
                           name: 'registry',
@@ -585,22 +587,22 @@ export default async function loadRealm<T extends TSchema>(
                               'watch',
                               'apiSchema',
                           ],
-                          load: () => import('./Registry.ts'),
+                          load: () => import(/* @vite-ignore */ './Registry' + extension),
                       },
                       {
                           name: 'codec',
                           deps: ['log'],
-                          load: () => import('./codec/server.ts'),
+                          load: () => import(/* @vite-ignore */ './codec/server' + extension),
                       },
                       {
                           name: 'orchestrator',
                           deps: ['log'],
-                          load: () => import('./orchestrator/index.ts'),
+                          load: () => import(/* @vite-ignore */ './orchestrator/index' + extension),
                       },
                       {
                           name: 'adapter',
                           deps: ['log'],
-                          load: () => import('./adapter/server.ts'),
+                          load: () => import(/* @vite-ignore */ './adapter/server' + extension),
                       },
                   ]),
         ]).map(({name, load}) => {
@@ -777,7 +779,9 @@ export default async function loadRealm<T extends TSchema>(
                                             platformApi.join(destUrl, 'package.json'),
                                         )
                                     ) {
-                                        const {createRealm} = await import('./kopi.ts');
+                                        const {createRealm} = await import(
+                                            /* @vite-ignore */ './kopi' + extension
+                                        );
                                         await createRealm(destUrl, logger);
                                         const mod = await import(/* @vite-ignore */ fileName);
                                         return mod.default ?? mod;

package/src/mle.ts

@@ -2,6 +2,7 @@ import type {FastifyInstance, FastifyRequest} from 'fastify';
 import fp from 'fastify-plugin';
 
 import jose from './jose.ts';
+import isPublic from './public.ts';
 
 export type IConfig = Parameters<typeof jose>[0] & {public: {sign: unknown; encrypt: unknown}};
 
@@ -14,6 +15,7 @@ export default fp<IConfig>(async function mlePlugin(fastify: FastifyInstance, co
     fastify.addHook(
         'preValidation',
         async (request: FastifyRequest<{Body: {jsonrpc?: string}}>, reply) => {
+            if (isPublic(request.originalUrl)) return;
             if (
                 request.routeOptions.config.auth &&
                 request.headers['content-type'] === 'application/json'
@@ -95,6 +97,7 @@ export default fp<IConfig>(async function mlePlugin(fastify: FastifyInstance, co
                       checkpoints?: unknown;
                   },
         ) => {
+            if (isPublic(request.originalUrl)) return payload;
             if (payload instanceof Error) return payload;
             const mlek =
                 request.auth?.credentials?.mlek ||
@@ -108,10 +111,7 @@ export default fp<IConfig>(async function mlePlugin(fastify: FastifyInstance, co
                 const encrypt: (message: object) => unknown = message =>
                     request.routeOptions.config.mle === false
                         ? message
-                        : mle.signEncrypt(
-                              message,
-                              mlek as {type: string},
-                          );
+                        : mle.signEncrypt(message, mlek as {type: string});
                 const where = payload.jsonrpc
                     ? payload
                     : {

package/src/public.ts

@@ -0,0 +1,9 @@
+export default function isPublic(path: string): boolean {
+    return (
+        path.startsWith('/documentation/') ||
+        path.startsWith('/s/') ||
+        path === '/favicon.ico' ||
+        path === '/s' ||
+        path === '/documentation'
+    );
+}

package/src/static.ts

@@ -0,0 +1,35 @@
+import helmet from '@fastify/helmet';
+import fastifyStatic from '@fastify/static';
+import type {FastifyInstance} from 'fastify';
+import fp from 'fastify-plugin';
+import path from 'path';
+
+export type IConfig = {
+    root: string;
+};
+
+export default fp<IConfig>(async function staticPlugin(fastify: FastifyInstance, config: IConfig) {
+    await fastify.register(helmet, {
+        contentSecurityPolicy: false, // Prevents helmet from wasting bytes on images/scripts/JSON
+    });
+    fastify.get('/favicon.ico', async (_request, reply) => {
+        return reply.sendFile('favicon.ico', import.meta.dirname);
+    });
+    fastify.register(fastifyStatic, {
+        root: config.root ?? path.join(process.cwd(), 'dist'),
+        prefix: '/s',
+        redirect: true,
+        preCompressed: true,
+        cacheControl: true,
+        maxAge: '1y',
+        immutable: true,
+        setHeaders: (res, filePath) => {
+            if (filePath.endsWith('.html')) {
+                res.header(
+                    'Content-Security-Policy',
+                    "default-src 'self';script-src 'self' 'unsafe-eval';style-src 'self' 'unsafe-inline'",
+                );
+            }
+        },
+    });
+});