rosefc 0.0.0-stage → 0.2.1

package/deploy/native/ios.yml

@@ -0,0 +1,67 @@
+# Rosefc - iOS build (GitHub Actions): an UNSIGNED archive.
+#
+# `rosefc export xcode` copies this file into the export tree as
+# .github/workflows/ios.yml, at the root of the exported Xcode project, so
+# every path below is the project's own. The shared scheme this archives is
+# emitted beside project.pbxproj by the same export.
+#
+# No credential is written into this file. A signed archive reads its
+# certificate from `${{ secrets.NAME }}` - see DEPLOY.md.
+
+name: iOS
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  archive:
+    runs-on: macos-14
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: List the project
+        run: xcodebuild -list -project RosefcApp.xcodeproj
+
+      # No certificate, no provisioning profile, no team: signing is switched
+      # off and the archive lands unsigned in build/. Installing or shipping
+      # it is the manual step - see DEPLOY.md.
+      - name: xcodebuild archive (unsigned)
+        run: |
+          xcodebuild archive \
+            -project RosefcApp.xcodeproj \
+            -scheme RosefcApp \
+            -configuration Release \
+            -destination 'generic/platform=iOS' \
+            -archivePath build/RosefcApp.xcarchive \
+            CODE_SIGNING_ALLOWED=NO \
+            CODE_SIGNING_REQUIRED=NO \
+            CODE_SIGN_IDENTITY=""
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: rosefc-ios-xcarchive
+          path: build/RosefcApp.xcarchive
+          if-no-files-found: error
+
+# Signed archive: add the certificate as repository secrets, import it into a
+# temporary keychain before the archive, and replace CODE_SIGNING_ALLOWED=NO
+# with `-allowProvisioningUpdates`.
+#
+#     env:
+#       IOS_CERT_P12_BASE64: ${{ secrets.IOS_CERT_P12_BASE64 }}
+#       IOS_CERT_PASSWORD: ${{ secrets.IOS_CERT_PASSWORD }}
+#       IOS_KEYCHAIN_PASSWORD: ${{ secrets.IOS_KEYCHAIN_PASSWORD }}
+#
+#     steps:
+#       - name: Import the signing certificate
+#         run: |
+#           echo "$IOS_CERT_P12_BASE64" | base64 -d > cert.p12
+#           security create-keychain -p "$IOS_KEYCHAIN_PASSWORD" build.keychain
+#           security default-keychain -s build.keychain
+#           security unlock-keychain -p "$IOS_KEYCHAIN_PASSWORD" build.keychain
+#           security import cert.p12 -k build.keychain -P "$IOS_CERT_PASSWORD" -T /usr/bin/codesign
+#           security set-key-partition-list -S apple-tool:,apple: -s -k "$IOS_KEYCHAIN_PASSWORD" build.keychain

package/deploy/netlify/functions/rosefc.ts

@@ -0,0 +1,36 @@
+/**
+ * The rosefc Netlify function - the dynamic half of a Netlify deploy.
+ *
+ * Every request that is NOT a static file in dist/ lands here: dynamic
+ * pages (/sign, anything reading getContext() or $store()), /api routes,
+ * and POST server actions. Static answers - prerendered documents, the
+ * bundles, baked API bodies - are served by the CDN straight from dist/
+ * (the `publish` directory) and never touch this code. That split is the
+ * whole rosefc story: the static half costs zero function invocations.
+ *
+ * It reuses the framework's own edge adapter (the same Web-standard fetch
+ * handler the edge adapter test exercises) over the built server bundle,
+ * on Netlify's Functions v2 Web-standard signature - `export default`
+ * taking a Request and returning a Response. Netlify compiles TypeScript
+ * entrypoints and their imports, so this file and the adapter it pulls in
+ * stay .ts. The Lambda runtime has a filesystem, so `included_files`
+ * (`dist/**` in netlify.toml) carries dist/ into the bundle and the
+ * adapter reads server.js / client.js from it at boot.
+ *
+ * Install: copy this file to <project>/netlify/functions/rosefc.ts and
+ * deploy/netlify.toml to <project>/netlify.toml, then push (or
+ * `netlify deploy --prod`). In a project that depends on the published
+ * package the import below becomes:
+ *   import { createEdgeHandler } from 'rosefc/edge';
+ */
+import { createEdgeHandler } from '../../src/cli/edge.ts';
+import { fileURLToPath } from 'node:url';
+
+let handle: ((request: Request) => Promise<Response>) | null = null;
+
+export default async function rosefc(request: Request): Promise<Response> {
+  if (!handle) {
+    handle = await createEdgeHandler(fileURLToPath(new URL('../../dist', import.meta.url)));
+  }
+  return handle(request);
+}

package/deploy/netlify.toml

@@ -0,0 +1,17 @@
+[build]
+  command = "npm run build"
+  publish = "dist"
+
+[functions]
+  directory = "netlify/functions"
+  included_files = ["dist/**"]
+
+# Netlify answers the publish directory first, so a prerendered document, a
+# bundle or a baked API body is served by the CDN and never invokes the
+# function. Everything else - dynamic routes, live /api routes, POST server
+# actions - falls through to the catch-all below (status 200 = rewrite, not
+# redirect; the browser keeps its URL).
+[[redirects]]
+  from = "/*"
+  to = "/.netlify/functions/rosefc"
+  status = 200

package/deploy/server.cjs

@@ -0,0 +1,4 @@
+import('./dist/prod.mjs').catch((err) => {
+  console.error('[server.cjs] failed to start dist/prod.mjs:', err);
+  process.exit(1);
+});

package/deploy/vercel.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "buildCommand": "npm run build",
+  "outputDirectory": "dist",
+  "functions": {
+    "api/rosefc.ts": {
+      "includeFiles": "dist/**"
+    }
+  },
+  "rewrites": [
+    { "source": "/(.*)", "destination": "/api/rosefc" }
+  ]
+}