@steve31415/baselib 3.34.1 → 3.36.0

package/dist/log-core.d.ts

@@ -21,10 +21,14 @@ export interface Logger {
 export interface SerializedError {
     name: string;
     message: string;
+    /** The error's own `code` (Node's `ECONNREFUSED`, Postgres SQLSTATE, an
+     *  app error's machine-readable reason), when it is a string or number. */
+    code?: string | number;
     stack?: string;
     cause?: {
         name: string;
         message: string;
+        code?: string | number;
     };
 }
 export declare function serializeError(err: unknown): SerializedError;

package/dist/log-core.js

@@ -10,11 +10,30 @@
 // ship-failure check counts. makeEvent also guards the shape of `meta`: every
 // distinct key is an Axiom column (see "Key-shape guard" below).
 export const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+const CODE_MAX = 100;
+/** An Error's `code` property when it is a primitive worth a column: a
+ *  string (capped) or a finite number. Anything else is dropped, since an
+ *  object there would mint `meta.error.code.*` keys from data. */
+function errorCode(err) {
+    const code = err.code;
+    if (typeof code === 'string')
+        return truncate(code, CODE_MAX);
+    if (typeof code === 'number' && Number.isFinite(code))
+        return code;
+    return undefined;
+}
 export function serializeError(err) {
     if (err instanceof Error) {
-        const out = { name: err.name, message: err.message, stack: err.stack };
+        const out = { name: err.name, message: err.message };
+        const code = errorCode(err);
+        if (code !== undefined)
+            out.code = code;
+        out.stack = err.stack;
         if (err.cause instanceof Error) {
             out.cause = { name: err.cause.name, message: err.cause.message };
+            const causeCode = errorCode(err.cause);
+            if (causeCode !== undefined)
+                out.cause.code = causeCode;
         }
         else if (err.cause !== undefined) {
             out.cause = { name: 'cause', message: truncate(String(err.cause), 500) };

package/dist/s2s.d.ts

@@ -7,8 +7,12 @@ import { type Logger } from './log-core.js';
  * disables the always-allow rule (fail closed). */
 export declare function codingAgentSa(): string | undefined;
 /** caller service-account email → allowed "METHOD /path" patterns.
- *  Patterns: exact ("GET /api/whoami"), trailing wildcard ("POST /api/admin/*"),
- *  or "*" for everything. */
+ *  Patterns: exact ("GET /api/whoami"), trailing wildcard ("POST /api/admin/*",
+ *  a prefix: the bare path and everything under it), a single-segment
+ *  wildcard anywhere else ("GET /api/tasks/*\/card": exactly one non-empty
+ *  segment in that position, so one task-scoped method can be granted without
+ *  the whole prefix — 2026-10-12, Radar's grant on Coder's card and decide
+ *  routes), or "*" for everything. */
 export type Grants = Record<string, string[]>;
 export interface ServiceCaller {
     type: 's2s';

package/dist/s2s.js

@@ -40,9 +40,20 @@ export function grantAllows(grants, email, method, path) {
             const prefix = p.slice(0, -1); // keep the trailing slash
             return want.startsWith(prefix) || want === p.slice(0, -2);
         }
+        if (p.includes('/*/'))
+            return segmentsMatch(p, want);
         return want === p;
     });
 }
+/** "METHOD /a/*\/b" against "METHOD /a/x/b": the same number of segments,
+ *  each equal or a `*` standing for exactly one non-empty segment. */
+function segmentsMatch(pattern, want) {
+    const ps = pattern.split('/');
+    const ws = want.split('/');
+    if (ps.length !== ws.length)
+        return false;
+    return ps.every((seg, i) => (seg === '*' ? ws[i].length > 0 : seg === ws[i]));
+}
 // Fixed-window per-identity rate limiter — a sanity check against runaway
 // loops and mischief, not a precision tool (per-instance state only).
 export class RateLimiter {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.34.1",
+  "version": "3.36.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",